s*****w
发帖数: 1527 | 1 class1 {
handler() {
try {
// basically 1 line here
sth1Facade.doSth();
} catch (e) {
...
}
}
}
sth1Facade {
doSth() {
// less than 8 lines here
sth2Facade.doSthElse();
foreach(
sth3Facade.doAnotherThing();
}
}
}
handler真正有用的就一句话，调用sth1Facade，尼玛这都是干嘛？非要加一个
sth1Facade，把逻辑放到sth1Facade里。 |
w***g
发帖数: 5958 | 2 java不都这样吗？
【在 s*****w 的大作中提到】
: class1 {
: handler() {
: try {
: // basically 1 line here
: sth1Facade.doSth();
: } catch (e) {
: ...
: }
: }
: }
|
c*******v
发帖数: 2599 | 3 放出来倒没啥。这是个名字错误吧。
doTing（）
doElseThing（）
doAnotherThing（）
这三个方法假如是同层次概念。我会放在一个类里面。
doxxthing
call 另一个doxxxthing，
后者应该改个名字。
【在 s*****w 的大作中提到】
: class1 {
: handler() {
: try {
: // basically 1 line here
: sth1Facade.doSth();
: } catch (e) {
: ...
: }
: }
: }
|
s*****w
发帖数: 1527 | 4 加一个wrapper真的有那么大的意义吗？
【在 w***g 的大作中提到】
: java不都这样吗？
|
a****i
发帖数: 1182 | 5 这个很明显是异常处理吧
不然在上一层你怎么做？每一行代码都加try catch？
【在 s*****w 的大作中提到】
: class1 {
: handler() {
: try {
: // basically 1 line here
: sth1Facade.doSth();
: } catch (e) {
: ...
: }
: }
: }
|
s*****w
发帖数: 1527 | 6 那为啥要sth1Facade，直接这么写不就是了？
class1 {
handler() {
try {
// less than 8 lines here
sth2Facade.doSthElse();
foreach(
sth3Facade.doAnotherThing();
}
} catch (e) {
...
}
}
}
【在 a****i 的大作中提到】
: 这个很明显是异常处理吧
: 不然在上一层你怎么做？每一行代码都加try catch？
|
d*******n
发帖数: 109 | 7 Facede 这名词 好像老的 Spring里经常用
我理解 handler 相当于一个 route 的 controller
Controller 通常要求 thin 目的是把逻辑 dispatch 到相应的 service里面
Service 可以写很多逻辑的而且 service 本身也可以有很多层
再到下面就是 repository layer 这层也需要thin
这里的 Facede 我感觉就是我service
代码这东西 没有对错 但是如果要成仙frameworks 就要有一定之规 而thin
controller 把业务逻辑下放到家Service 就是说Spring 或者java web frame用的 大
家认可的那个规矩 |
s*****w
发帖数: 1527 | 8 新的java framework还这么搞吗？
【在 d*******n 的大作中提到】
: Facede 这名词 好像老的 Spring里经常用
: 我理解 handler 相当于一个 route 的 controller
: Controller 通常要求 thin 目的是把逻辑 dispatch 到相应的 service里面
: Service 可以写很多逻辑的而且 service 本身也可以有很多层
: 再到下面就是 repository layer 这层也需要thin
: 这里的 Facede 我感觉就是我service
: 代码这东西 没有对错 但是如果要成仙frameworks 就要有一定之规 而thin
: controller 把业务逻辑下放到家Service 就是说Spring 或者java web frame用的 大
: 家认可的那个规矩
|
a****i
发帖数: 1182 | 9 是可以啊，但是多了一层try catch，比较难看
代码写了是人看的不是
convention大家都在handler里catch，doSomething()着重在logic上
没什么不对
【在 s*****w 的大作中提到】
: 那为啥要sth1Facade，直接这么写不就是了？
: class1 {
: handler() {
: try {
: // less than 8 lines here
: sth2Facade.doSthElse();
: foreach(
: sth3Facade.doAnotherThing();
: }
: } catch (e) {
|
s*****w
发帖数: 1527 | 10 你的意思是down stream的exception全都bubble up到handler()这一层来catch ?
这个倒是不错。虽然我觉得在handler里catch 2+ facade也行，不必要只能一个facade.
【在 a****i 的大作中提到】
: 是可以啊，但是多了一层try catch，比较难看
: 代码写了是人看的不是
: convention大家都在handler里catch，doSomething()着重在logic上
: 没什么不对
|
n******t
发帖数: 4406 | 11 美國人的公司不能把人可以不幹活也可以拿工資寫到檯面上的結果就是全是這種code。
目的只有一個就是證明自己存在有價值。
【在 s*****w 的大作中提到】
: class1 {
: handler() {
: try {
: // basically 1 line here
: sth1Facade.doSth();
: } catch (e) {
: ...
: }
: }
: }
|
m****a
发帖数: 2593 | 12 https://www.mitbbs.com/article/Programming/31544451_0.html
比如print一句hello world吧。main函数里print一下？太面向过程，太low了。
得封装一个类。叫Printer. Printer有个成员方法，叫print。但是！光一个类太low
了，以后要是有不同的实现怎么办？所以得加一个接口。PrinterInterface。
但是！interface是没有实现的，还是要有默认实现才行。所以得加个虚拟类，
AbstractPrinter实现PrinterInterface，然后Printer继承AbstractPrinter。但是！
你有了那么一套，该怎么创建实例呢？直接new Printer()？太low了，那叫实现依赖。
肯定不行的，所以要搞一个工厂类，PrinterFactory，PrinterFactory用
PrinterInterface返回实例，这样就隐藏了实现细节了。但是！PrinterFactory本身也
是实现类啊，太low了，所以得有PrinterFactoryInterface, AbstractPrinterFactory
. 而且在PrinterFactory里面该怎么写呢？直接new Printer()? 太low了。还是实现依
赖。
最后，你要把这一堆玩意在代码里组装起来，也太难看了，各种new实现类。太low！好
在我们有个高级玩意，叫依赖注入！把程序对象结构全写到配置文件里面。这一套当然
是不能自己造轮子的。配置Spring吧。搞了那么多lib，靠命令行或者IDE的项目管理肯
定不够啊，得有依赖管理。
Maven啊Gradle啊使劲上。最最后，要print的东西怎么传给程序呢？硬编码？命令行传
参数？太low！当然得写在XML里头。光是XML当然还不够企业级，再加上DTD验证吧。然
后就涉及到了XML解析的问题了。代码里直接操起parser吗？太low! 当然要写个parser
的包装类，interface, abstract class, implementation class, factory class再来
一套。
毕竟，不能依赖实现啊，以后我要是换parser了怎么办。所以最后是成品是一堆配置文
件，一堆jar，compile出来的程序200MB。IDE得装上300个插件，打开项目硬盘响老半
天吃掉2GB内存，然后一堆插件弹提示要求升级。哦对了，在这一切发生之前，还得画
UML图呢。三年后项目完工了，部署到客户的服务器上一跑，立马崩溃，一地的stack
trace。
原来客户服务器上用的是JDK 8而新项目需要JDK 11. 然后问客户你们不能升级吗，答
案是不行，因为另外一个企业级开发组给做的企业级解决方案只支持JDK 8。接着客户
把你们的架构师臭骂了一顿，你搞了那么多设计就没有想过可能会换JDK吗？
http://www.mitbbs.com/bbsann2/chinese.faq/WashingtonDC/D13455539052B0/M.1334766600_2.D0/.NET%D6%AA%CA%B6%B5%E3
1：懂得直接写HELLO WORLD
2:懂得弄个function，然后整出HELLO WORLD
3：懂得弄个Interface+Abstract Class+Implement Class写出HELLO WORLD
4：懂得Dependency Injection依然是弄出个HELLO WORLD
5：Predicate Builder/Reflection
6：常用的Design Pattern: Data Repository/Factory method/Singleton
3-6都精通，保证你年薪6位以上，而且基本是摸到框架师的边了
====================================================
链接：https://www.zhihu.com/question/23757237/answer/25564019
一句话To A Man with a Hammer, Everything Looks Like a Nail.举个明白点的例子
，转个之前看到的东西让我们专注于这个例子。这个问题很经典：写一个在标准输出打
印“你好世界！”的程序（在 Java 中）：System.out.println("hello world");代码
看起来太简单了。让我们能不能用用几个设计模式？看看……首先我们定义两个接口对
象和监听器来增加监听器。public interface Subject {
public void attach(Observer observer);
public void detach(Observer observer);
public void notifyObservers();
}
public interface Observer {
public void update(Subject subject);
}再定义 HelloWorldSubject 和 HelloWorldObserver 然后实现它们。 private
ArrayList observers;
private String str;
public HelloWorldSubject() {
super();
observers = new ArrayList();
}
public void attach(Observer observer) {
observers.add(observer);
}
public void detach(Observer observer) {
observers.remove(observer);
}
public void notifyObservers() {
Iterator iter = observers.iterator();
while (iter.hasNext()) {
Observer observer = iter.next();
observer.update(this);
}
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
notifyObservers();
}
}
public class HelloWorldObserver implements Observer {
public void update(Subject subject) {
HelloWorldSubject sub = (HelloWorldSubject)subject;
System.out.println(sub.getStr());
}
}然后我们增加一个命令。public interface Command {
void execute();
}
public class HelloWorldCommand implements Command {
private HelloWorldSubject subject;
public HelloWorldCommand(Subject subject) {
super();
this.subject = (HelloWorldSubject)subject;
}
public void execute() {
subject.setStr("hello world");
}
}然后我们增加一个抽象工厂。public interface AbstractFactory {
public Subject createSubject();
public Observer createObserver();
public Command createCommand(Subject subject);
}
public class HelloWorldFactory implements AbstractFactory {
public Subject createSubject() {
return new HelloWorldSubject();
}
public Observer createObserver() {
return new HelloWorldObserver();
}
public Command createCommand(Subject subject) {
return new HelloWorldCommand(subject);
}
}然后最后地，一个单件。public class FactoryMakerSingleton {
private static FactoryMakerSingleton instance = null;
private AbstractFactory factory;
private FactoryMakerSingleton() {
factory = new HelloWorldFactory();
}
public static synchronized FactoryMakerSingleton getInstance() {
if (instance == null) {
instance = new FactoryMakerSingleton();
}
return instance;
}
public AbstractFactory getFactory() {
return factory;
}
}最后是主类。public class AbuseDesignPatterns {
public static void main(String[] args) {
AbstractFactory factory = FactoryMakerSingleton.getInstance().
getFactory();
Subject subject = factory.createSubject();
subject.attach(factory.createObserver());
Command command = factory.createCommand(subject);
command.execute();
}
}然后输出：Hello World哇，我们在 Hello World 中用了四个设计模式耶！（好吧，
其实还有一个迭代器，但我们使用了 Java 的内建迭代器）这一定是一个优秀的设计! |
a****i
发帖数: 1182 | 13 是这个意思
至于你觉得怎么样更好，可以在组里提出来，让大家follow
facade.
【在 s*****w 的大作中提到】
: 你的意思是down stream的exception全都bubble up到handler()这一层来catch ?
: 这个倒是不错。虽然我觉得在handler里catch 2+ facade也行，不必要只能一个facade.
|
