Micro-channel public number [yellow] small ramp programmer manufacturers, the Internet industry new knowledge, lifelong learning practitioner. After concerns reply "Java", "Python", "C ++", "big data", "machine learning", "algorithm", "AI", "Android", "front-end", "iOS", "PubMed", " BAT "," school trick "," written "," interview "," surface can be obtained via the corresponding free learning materials "," computer Basics "," LeetCode "and other keyword.
Java Java Empire bean (on)
Editor: Liu Xin yard farmers stand 2016-05-27
Introduction: Recently seen to bean configuration of spring, suddenly thought of a lot of people might not necessarily know the ins and outs of bean called something, so I wrote articles speaking about.
In addition, the last time the Open Source China plagiarism incident , in order to prevent future public reprint my number information was deliberately deleted, I added some of Liu Xin in the article's content: words such (micro-channel public number farmers turn over), possible will cause some annoyance, please forgive me.
I single-handedly created the Java Empire has just set up soon, will be a huge blow, I sent troops to occupy the desktop development almost completely annihilated.
Intelligence says Microsoft's Visual Basic and Borland Delphi recent publicity what component-based development, which is to do something to break us up?
Liu Xin (micro-channel public number: Code farmers turn over) Note: See " the Java: the birth of an empire " and " Basic: a veteran readme "
I quickly bought a Visual Basic research came, sure enough, this guy is really convenient, most amazes me is that: it has a visual editor!
I just need a component (such as buttons) to be a drag on the form, set about the properties (color, font), and then add an event (onClick), and finally to write code in onClick to get!
Not only that, I can put my code according to specifications packed into a component, advertised for others to use.
I looked at my hands bought "programmer base camp" CD-ROM, inside actually contain several thousands of such components, assemblies have a database browsing, timer component, color picker component, and even send and receive e-mail components .. ....
God, this program would not later develop desktop too simple!
No wonder my Java was beaten Mandizhaoya!
Liu Xin (micro-channel public number: Code farmers turn over) Note: in the late 1990s estimated programmers and students know that "programmers Camp", produced by Jiang Tao, founder of csdn.
I quickly called my brother go-getters small code: S ah, you quickly see that Visual Basic and Delphi, to give you seven days time, we've got to do a set of Java also such things out.
Small it unequivocally three days gave me out a thing out: Java Bean API specification.
I turned to look, Wow, up to 114, then asked him: "?? This is what I want to do a visual editor Visual Java it."
Liu Xin (micro-channel public number: Code farmers turn over) Note: I downloaded the browser java bean norms, indeed 114
He said: "Boss, we're an open source community, have to take full advantage of our strengths, so I did not do something like VB and Delphi as, on the contrary, I define a set of specifications, as long as we do in accordance with this standard, no one you can make visual development tools such as VB with java as out. "
"Then you talk about the java bean in the end is what specification?" I asked.
"First of all, a java bean is actually a normal java class, but some of our requirements for this class:
1. This class needs to be public, then there is no need for argument constructor
2. This class of property should be private, accessible through setXXX () and getXXX ()
3. This class needs to be able to support the "event", such as addXXXXListener (XXXEvent e), the event may be the Click event, Keyboard events, and so, of course, we also support custom events.
4. We have to provide a so-called introspection / reflection, this can view a variety of information java bean at runtime "
5. This class should be serializable, i.e., can be saved on the hard state bean, so as to be later restored.
"These requirements appear to have nothing ah, the programmer, not that ordinary java class do? In the end how to use?"
"We dream about, assuming our Java bean popular, have a user with a Visual Java Builder of such visual development tools, when he created the application using this tool, they can select the components named JButton that added to a form on this point Visual Java Builder will need this class to the new JButton out by reflection, so we need a no-argument constructor of the. "
"If you want to set about this JButton properties, Visual Java Builder you need to use introspection / reflection to get this JButton which attributes (via getter / setter), later you can get a display to the user attribute list of, for example, background color, font, etc. the user can set the background after seeing colors and fonts, this time Visual Java Builder inside need to call the Bean's setBackgroundCorlor () / setFont () methods, which is called the setXXXX () method."
"If you want to have what events this JButton programming, Visual Java Builder or to obtain this JButton through introspection / reflection on, to show users a list of events , such as click, keyboardPressed user can select one, and then you can write a program for this event programming a. "
"But the sequence of what use is it?"
"This is because the user design is over, you may turn off the Visual Java Builder ah, if not through serialization designed to save up JButton, next time you open the Visual Java Builder, may have nothing."
I thought, good brother small yard design, with only a simple specification would meet all the requirements of the visual editor.
"Then we publish this specification it, we own do a visual editor, be a role model to others, I want a good name, called NetBean it."
Liu Xin (micro-channel public number: Code farmers turn over) Note: This is what I coined, in fact NetBean name and java bean may not actually related.
Sure enough we expected, after the release Java bean, a strong market led to the Java IDE, Borland's Delphi development company getting into his foot, come up with a JBuilder, all the rage.
IBM engage in a Visual Age for Java, later transformed into a called Eclipse open platform, super welcomed by everyone, it is far as to put our Netbean and force JBuilder fast no way out.
Although we had a good laugh, but programmers do not buy it, Java developers in the desktop market is still no improvement, use Java bean to create desktop programmers few, as only part of the financial, ERP such a territory still persist.
It seems hopeless.
But Java bean go from here? Discarded pity, and I talk a bit small yards brother, we think: Now that we reign in the Java programming server, or think of a way where it ......
Previous mention Java bean specifications although the definition of good, but not in the expected success, especially on the Java Desktop Empire expected development components market.
And my little brother how code can also look forward to CSDN out a "programmer base camp" offer, which contains thousands of java bean component ah.
Do not imagine, and quickly put the application on the server side java bean is down to business.
JSP + Java Bean
Codelets brother recommended to use in jsp try java bean can be used to encapsulate the business logic, data stored in the database, like this:
(Micro-channel public number "code farmers turn over." Note: This is actually called the JSP Model 1)
Wherein jsp directly to accept the user's request, and then processed by the traffic java bean, particular use is:
This can all parameters are set in the HTTP request to the user the java bean corresponding property up.
If you want to be lazy, you can also this:
Of course, to ensure that the http request parameter names and attribute names java bean is the same.
This model is called the JSP Model 1 has been welcomed by many Java programmers, because their applications are small, with Model 1 allows developers to very quickly.
In fact, asp in this way and the Microsoft empire, as well as open source php and almost the same.
But soon someone came to me complaining that their projects using the collapse of the entire system, resulting in Model 1.
He said: "You know our system has many thousands of jsp, jsp these calls with each other (via GET / POST), the last call to the relationship and no one can get to know?."
In fact, we had expected, the little brother of this code has a vivid metaphor: spaghetti
This is like a bowl of noodles thousands JSP, like, stir together the fundamental reason is not clear.
To solve this problem, little brother has introduced a code: JSP Model 2, which is a model of truly reflects the Model-View-Controller ideas:
Servlet acts as a Controller, jsp act as a View
Model is a Java bean course!
Business logic, the page is displayed, and the process to do a good separation.
Based expand and improve this model, many Web development framework began springing up like the rest, most notably Struts, SpringMVC up.
Java Web development quickly prospered.
Once again, we come to understand the benefits of open!
Enterprise Java bean
But it did not last long, since Java Empire ruled the so-called "enterprise application" development territory, a variety of endless marches and protests:
"We want distributed"
"We want security"
"We want Affairs"
"We want high availability"
“......”
Empire analysis of what, in fact, these demands can be attributed to the programmer:
"We just want to focus on our business logic, we do not want, should not be up to us to deal with 'low' affairs, multithreading, connection pooling, and various other variety of 'low-level' API, in addition Java Empire got to offer clustering capabilities, we are a machine crashes later, the entire system can operate. "
We can not sit and do not care, enterprise applications are our lifeblood.
Small code Geche night work, and ultimately come up with something called J2EE, like Java bean, as this is a norm, but more complex than Java bean, which are:
JDBC : the Java Database Connectivity, without the support of the database how can they say enterprise applications?
The JNDI : the Java Naming and Directory Interface, by a name you can navigate to a data source, jdbc even do not have a connection
RMI : Remote Procedure Call, let java objects on a machine can call another java objects on a machine, you are not to be distributed it?
JMS : the Java Message Service, you can use the message queue, this is not a great need for enterprise-class applications do?
JTA : the Java transaction management, support for distributed transactions, to access, update multiple databases, it still ensures transaction, or distributed.
Mail the Java : mail is essential ah.
Liu Xin (micro-channel public number number: Code farmers turn over) Note: J2EE later changed Java EE.
Of course, by far the most important upgrade, the little brother code into a java bean Enterprise the Java bean , referred to as the EJB .
Small yards brother declared:
Using EJB, you can focus only on business, and those annoying transaction management, security management, thread all to the container (application server) to deal with it.
We also offer additional benefits, as long as your application server is a cluster composed of multiple machines, EJB can run seamlessly on this cluster, you no need to consider a machine crashes the application how to do. We have the seal the deal.
Use Session Bean, you can easily handle your business.
Entity Bean (Entity bean), you interact with the database becomes very easy, even without writing a sql.
Using message-driven Bean (Message Driven bean), you can easily connect and a message queue, process the message.
Sounds nice is not it?
Enterprise-class development territory programmers cheered, riding on a J2EE boat, all of a sudden seem noble, and began to despise "mediocre" in the language of Microsoft's ASP, open source PHP, Python waited.
Weblogic, Websphere and other J2EE-compliant application server, taking advantage of the, beating the drums, as if a new era is coming, of course, they have been muffled fortune behind.
sring
There is a saying, the higher the holding, fall more miserable.
Soon, most of the programmers found a bright future and not implemented, EJB used up very tedious and cumbersome, performance is not good, in order to obtain so-called distributed, but carry a heavy yoke.
Entity Bean soon no one used, even simple stateless Session bean has also been criticized by everyone, one of which counts is the "invasive code."
Also, little brother define EJB code when not so much to consider, in the definition of a programmer Session bean when the need to write a lot of business and has nothing to do classes.
Also we need to be forced to implement some interface and its methods should not have realized:
To even a little bit of business logic, we have to write so many useless code! Programmers out of anger!
They launched a campaign called the POJO (Plain Old Java Object) movement, singing this song POJO, we are required rectification.
They want to look like this:
public class HelloworldBean{
public String hello(){
return "hello world"
}
}
At the same time, they have too much to ask to retain affairs, and security of these essential things.
Programmers do not wait, but we have been Weblogic, Websphere these bigwigs "kidnapping" and want to change easier said than done!
In 2002, small yards brother to see Rod Johnson wrote a book "Expert one on one J2EE development withoutEJB", and quickly came to me:
"Boss, bad bad, you quickly look at this book it, this guy called Rod wrote this book Watch our Vital, Zhesi engage in without EJB"
(Micro-channel public number "code farmers turn over" Note: Although this is a poor translation of the book, but because it is a pioneer for spring, it is worth reading, it is best bilingual)
Is more than without EJB, he "secretly" to launch a framework of what is called Spring, has quickly pop open.
Spring framework conforms to the trend of POJO, provides a spring container to manage these POJO, fun is also called bean.
It seems our java bean walk in a circle back to the origin.
For a Bean, if you rely on another Bean, you can just declare, spring bean container is responsible for the dependent to "inject into" At first we called Inversion of Control (IoC)
Later, Martin flower in this way up to a better name, called "dependency injection."
If you need something like a Bean affairs, logs, security of such universal service is to just declare, spring container can be dynamically at runtime of "weaving" These services, called AOP.
Later, my brother and small yards discuss, we also learn EJB Spring, simplified development and deployment, but it was too late, Spring has become the de facto standard! Programmers spring has been taken away!
However, we are heartened that, spring and spring mvc greatly increased our dominance of web development territory, java a powerful empire more.
(Applause.)
Spring nature series (1) - dependency injection
Editor: Liu Xin yard farmers stand 2016-06-25
Agricultural micro channel code reproduced stand 2016-06-25 Liu Xin public number "nature of the Spring series (1) - dependency injection"
1. Creating an object
Object-oriented programming language is to abstract the real world with a class (Class), these classes at runtime will generate the object (Object).
Of course, a single or a few objects simply no way to perform complex operations, the actual system is composed of hundreds of thousands of objects, and these objects need to cooperate with each other in order to work, such as method calls the object A object B, that inevitably raises the question: how to get the object a references object B it?
The easiest way is simply: When the object A need to use the object B, give it to new out, which is the most common way, java is not doing so? For example: Apple a = new Apple () ;
later the business is complicated, abstract of a fruit (Fruit) class, create objects will become like this:
Fruit f1 = new new the Apple ();
Fruit Banana new new F2 = () ;
Fruit = F3 ......
naturally, there will be similar to the following code:
If such a code scattered everywhere, it will be painful to maintain, for example, you add a new type of fruit Orange, it was found that all of these places to create Fruit of the system be modified, this is definitely a nightmare.
The solution is simple, predecessors already sum up: the factory pattern
工厂模式，以及其他模式像抽象工厂， Builder模式提供的都是创建对象的方法。这背后体现的都是“封装变化”的思想。这些模式只是一些最佳实践而已： 起了一个名称、描述一下解决的问题、使用的范围和场景，码农们在项目中还得自己去编码实现他们。
2. 解除依赖
我们再来看一个稍微复杂一点， 更加贴近实际项目的例子：
一个订单处理类，它会被定时调用： 查询数据库中订单的处理情况， 必要时给下订单的用户发信。
看起来也没什么难度， 需要注意的是很多类一起协作了， 尤其是OrderProcessor , 它依赖于OrderService 和 EmailService这两个服务，它获取依赖的方式就是通过单例方法。
如果你想对这个process方法进行单元测试--这也是很多优秀的团队要求的-- 麻烦就来了。
首先OrderService 确实会从真正的数据库中取得Order信息，你需要确保数据库中有数据， 数据库连接没问题，实际上如果数据库连接Container（例如Tomcat）管理的， 你没有Tomcat很难建立数据库连接。
其次这个EmailService 真的会对外发邮件， 你可不想对真正的用户发测试邮件，当然你可以修改数据库，把邮件地址改成假的，但那样很麻烦， 并且EmailService 会抛出一堆错误来，很不爽。
所有的这些障碍， 最终会导致脆弱的单元测试： 速度慢， 不可重复，需要手工干预，不能独立运行。
想克服这些障碍， 一个可行的办法就是不在方法中直接调用OrderService和EmailService的getInstance()方法， 而是把他们通过setter方法传进来。
通过这种方式，你的单元测试就可以构造一个假的OrderService 和假的EmailService 了。
例如OrderService 的冒牌货可以是MockOrderService , 它可以返回你想要的任何Order 对象， 而不是从数据库取。MockEmailService 也不会真的发邮件， 而是把代码中试图发的邮件保存下来， 测试程序可以检查是否正确。
你的测试代码可能是这样的：
当然， 有经验的你马上就会意识到： 需要把OrderService 和 EmailService 变成 接口或者抽象类， 这样才可以把Mock对象传进来。
这其实也遵循了面向对象编程的另外一个要求： 对接口编程， 而不是对实现编程。
3. Spring 依赖注入
啰啰嗦嗦说了这么多， 快要和Spring扯上关系了。
上面的代码其实就是实现了一个依赖的注入，把两个冒牌货注入到业务类中(通过set方法)， 这个注入的过程是在一个测试类中通过代码完成的。
既然能把冒牌货注入进去， 那毫无疑问，肯定也能把一个正经的类安插进去， 因为setter 方法接受的是接口，而不是具体类。
用这种方式来处理对象之间的依赖， 会强迫你对接口编程， 好处显而易见。
随着系统复杂度的增长， 这样的代码会越来越多， 最后也会变得难于维护。
能不能把各个类之间的依赖关系统一维护呢？
能不能把系统做的更加灵活一点，用声明的方式而不是用代码的方式来描述依赖关系呢？
肯定可以， 在Java 世界里，如果想描述各种逻辑关系， XML是不二之选：
这个xml 挺容易理解的， 但是仅仅有它还不够， 还缺一个解析器（假设叫做XmlAppContext）来解析，处理这个文件，基本过程是：
0. 解析xml, 获取各种元素
1. 通过Java反射把各个bean 的实例创建起来： com.coderising.OrderProcessor , OrderServiceImpl, EmailServiceImpl.
2. 还是通过Java反射调用OrderProcessor的两个方法：setOrderService(....) 和 setEmailService(...) 把orderService , emailService 实例 注入进去。
应用程序使用起来就简单了：
XmlAppContext ctx = new XmlAppContext("c:\\bean.xml");
OrderProcessor op = (OrderProcessor) ctx.getBean("order-processor");
op.process();
其实Spring的处理方式和上面说的非常类似， 当然Spring 处理了更多的细节，例如不仅仅是setter方法注入， 还可以构造函数注入，init 方法， destroy方法等等， 基本思想是一致的。
既然对象的创建过程和装配过程都是Spring做的， 那Spring 在这个过程中就可以玩很多把戏了， 比如对你的业务类做点字节码级别的增强， 搞点AOP什么的， 这都不在话下了。
4. IoC vs DI
“不要给我们打电话，我们会打给你的(don‘t call us, we‘ll call you)”这是著名的好莱坞原则。
在好莱坞，把简历递交给演艺公司后就只有回家等待。由演艺公司对整个娱乐项目完全控制，演员只能被动式的接受公司的差使,在需要的环节中，完成自己的演出。
这和软件开发有一定的相似性， 演员们就像一个个Java Object, 最早的时候自己去创建自己所依赖的对象， 有了演艺公司（Spring容器）的介入，所有的依赖关系都是演艺公司搞定的， 于是控制就翻转了
Inversion of Control, 简称IoC。 但是IoC这个词不能让人更加直观和清晰的理解背后所代表的含义， 于是Martin Flower先生就创造了一个新词 : 依赖注入 (Dependency Injection，简称DI), 是不是更加贴切一点？
Spring本质系列(2)-AOP
原创： 刘欣 码农翻身 2016-06-30
据说有些词汇非常热门和神奇， 如果你经常把它挂在嘴边，就能让自己功力大涨， 可以轻松找到理想的高薪的工作，这些词就包括上一篇文章(《Spring本质系列(1) --依赖注入》)中聊过的IoC 和 DI， 也包括今天要聊的AOP。
AOP（Aspect Oriented Programming）就是面向切面的编程， 为什么是面向切面， 而不是面向对象呢？
1. 问题来源
我们在做系统设计的时候，一个非常重要的工作就是把一个大系统做分解， 按业务功能分解成一个个低耦合、高内聚的模块，就像这样：
但是分解以后就会发现有些很有趣的东西， 这些东西是通用的，或者是跨越多个模块的：
日志： 对特定的操作输出日志来记录
安全：在执行操作之前进行操作检查
性能：要统计每个方法的执行时间
事务：方法开始之前要开始事务， 结束后要提交或者回滚事务
等等....
这些可以称为是非功能需求， 但他们是多个业务模块都需要的， 是跨越模块的， 把他们放到什么地方呢？
最简单的办法就是把这些通用模块的接口写好， 让程序员在实现业务模块的时候去调用就可以了，码农嘛，辛苦一下也没什么。
这样做看起来没问题， 只是会产生类似这样的代码：
这样的代码也实现了功能，但是看起来非常的不爽， 那就是日志，性能，事务 相关的代码几乎要把真正的业务代码给淹没了。
不仅仅这一个类需要这么干， 其他类都得这么干， 重复代码会非常的多。
有经验的程序员还好， 新手忘记写这样的非业务代码简直是必然的。
2. 设计模式：模板方法
用设计模式在某些情况下可以部分解决上面的问题，例如著名的模板方法：
在父类（BaseCommand）中已经把那些“乱七八糟“的非功能代码都写好了， 只是留了一个口子（抽象方法doBusiness()）让子类去实现。
子类变的清爽， 只需要关注业务逻辑就可以了。
调用也很简单，例如：
BaseCommand cmd = ... 获得PlaceOrderCommand的实例...
cmd.execute();
但是这样方式的巨大缺陷就是父类会定义一切： 要执行哪些非功能代码， 以什么顺序执行等等
子类只能无条件接受，完全没有反抗余地。
如果有个子类， 根本不需要事务， 但是它也没有办法把事务代码去掉。
3. 设计模式：装饰者
如果利用装饰者模式， 针对上面的问题，可以带来更大的灵活性：
现在让这个PlaceOrderCommand 能够打印日志，进行性能统计
Command cmd = new LoggerDecorator(
new PerformanceDecorator(
new PlaceOrderCommand()));
cmd.execute();
如果PaymentCommand 只需要打印日志，装饰一次就可以了：
Command cmd = new LoggerDecorator(
new PaymentCommand());
cmd.execute();
可以使用任意数量装饰器，还可以以任意次序执行（严格意义上来说是不行的）， 是不是很灵活？
4. AOP
如果仔细思考一下就会发现装饰者模式的不爽之处:
(1) 一个处理日志/性能/事务 的类为什么要实现 业务接口（Command）呢?
(2) 如果别的业务模块，没有实现Command接口，但是也想利用日志/性能/事务等功能，该怎么办呢？
最好把日志/安全/事务这样的代码和业务代码完全隔离开来，因为他们的关注点和业务代码的关注点完全不同 ，他们之间应该是正交的，他们之间的关系应该是这样的：
如果把这个业务功能看成一层层面包的话， 这些日志/安全/事务 像不像一个个“切面”(Aspect) ？
如果我们能让这些“切面“能和业务独立， 并且能够非常灵活的“织入”到业务方法中， 那就实现了面向切面编程(AOP)！
5. 实现AOP
现在我们来实现AOP吧， 首先我们得有一个所谓的“切面“类(Aspect)， 这应该是一个普通的java 类,不用实现什么“乱七八糟”的接口。以一个事务类为例：
我们想达到的目的只这样的： 对于com.coderising这个包中所有类的execute方法， 在方法调用之前，需要执行Transaction.beginTx()方法， 在调用之后， 需要执行Transaction.commitTx()方法。
暂时停下脚步分析一下。
“对于com.coderising这个包中所有类的execute方法” ， 用一个时髦的词来描述就是切入点（PointCut） , 它可以是一个方法或一组方法（可以通过通配符来支持，你懂的）
”在方法调用之前/之后 ， 需要执行xxx“ , 用另外一个时髦的词来描述就是通知（Advice）
码农翻身认为，PointCut,Advice 这些词实在是不直观， 其实Spring的作者们也是这么想的 : These terms are not Spring-specific… unfortunately, AOP terminology is not particularly intuitive; however, it would be even more confusing if Spring used its own terminology.
当然，想描述这些规则， xml依然是不二之选：
注意：现在Transaction这个类和业务类在源代码层次上没有一点关系，完全隔离了。隔离是一件好事情， 但是马上给我们带来了大麻烦 。
Java 是一门静态的强类型语言， 代码一旦写好， 编译成java class 以后 ，可以在运行时通过反射（Reflection）来查看类的信息， 但是想对类进行修改非常困难。
而AOP要求的恰恰就是在不改变业务类的源代码（其实大部分情况下你也拿不到）的情况下， 修改业务类的方法, 进行功能的增强，就像上面给所有的业务类增加事务支持。
为了突破这个限制，大家可以说是费尽心机， 现在基本是有这么几种技术：
(1) 在编译的时候， 根据AOP的配置信息，悄悄的把日志，安全，事务等“切面”代码 和业务类编译到一起去。
(2) 在运行期，业务类加载以后， 通过Java动态代理技术为业务类生产一个代理类， 把“切面”代码放到代理类中， Java 动态代理要求业务类需要实现接口才行。
(3) 在运行期， 业务类加载以后， 动态的使用字节码构建一个业务类的子类，将“切面”逻辑加入到子类当中去, CGLIB就是这么做的。
Spring采用的就是(1) +(2) 的方式，限于篇幅，这里不再展开各种技术了， 不管使用哪一种方式， 在运行时，真正干活的“业务类”其实已经不是原来单纯的业务类了， 它们被AOP了 ！、
A technical station Ali Java engineers. Author Huang oblique, focused Java related technologies: SSM, SpringBoot, MySQL, distributed, middleware, cluster, Linux, network, multi-threaded, occasionally speaking point Docker, ELK, as well as dry goods and technology to share the learning experience, committed to Java full stack development! (No reply after public concern "Java" Java can receive basic, advanced, and the project architect and other free learning materials, more databases, distributed, service and other popular micro learning video technology, rich content, both theory and practice, also presented will be the original author of the study guide Java, Java programmer interview guide and other dry goods resources)