Detailed explanation of Spring IoC and AOP principles

Detailed explanation of SpringIOC and AOP principles

IoC (Inversion of Control)

(1) . IoC (Inversion of Control) refers to the relationship between container-controlled program objects, rather than being directly controlled by program code in traditional implementations. Control is transferred from the application code to the external container. The transfer of control is called inversion. For Spring, Spring controls the life cycle of objects and the relationship between objects; IoC has another name - "Dependency Injection". As the name suggests, the so-called dependency injection means that the dependencies between components are determined by the container during runtime, that is, the container dynamically injects certain dependencies into the components.

(2). In the way Spring works, all classes will be registered in the spring container, telling spring what it is and what you need, and then spring will run it when the system is appropriate. Offer to give you what you want, and also give you to other things that need you. The creation and destruction of all classes are controlled by spring, which means that the object's life cycle is no longer controlled by the object that references it, but by spring. For a specific object, it used to control other objects, but now all objects are controlled by spring, so this is called inversion of control.

(3). During system operation, dynamically provide an object with other objects it needs.

(4). The idea of ​​dependency injection is realized through the reflection mechanism. When instantiating a class, it calls the set method in the class through reflection to inject the class attributes previously saved in the HashMap into the class. All in all, in the traditional method of object creation, the caller usually creates an instance of the callee. In Spring, the work of creating the callee is completed by Spring, and then the caller is injected, which is the so-called dependency injection or control reflection. change. There are two injection methods: dependency injection and setting injection; The advantages of IoC: reduce the coupling between components, reduce the complexity of replacement between business objects, and enable flexible management of objects.

AOP (Aspect Oriented Programming)

(1). AOP aspect-oriented programming is based on IoC and is a useful supplement to OOP;

(2 ). AOP uses a technology called "cross-cutting" to dissect the inside of the encapsulated object and encapsulate the public behaviors that affect multiple classes into a reusable module and name it "Aspect". That is, aspects. The so-called "aspect", simply put, is to encapsulate the logic or responsibilities that have nothing to do with the business but are jointly called by the business modules, such as logging, so as to reduce the duplication of code in the system, reduce the coupling between modules, and have Conducive to future operability and maintainability.

(3). AOP represents a horizontal relationship, comparing the "object" to a hollow cylinder, which encapsulates the properties and behavior of the object; the method of aspect-oriented programming is to This cylinder is cut into sections to selectively provide business logic. And the cut sections are the so-called "aspects". Then it restored these cut sections with uncanny skills, leaving no trace but completing the effect.

(4). The technology to implement AOP is mainly divided into two categories: one is to use dynamic proxy technology to decorate the message by intercepting the message to replace the execution of the original object behavior; The second is to use static weaving to introduce specific syntax to create "aspects", so that the compiler can weave code related to "aspects" during compilation.

(5). Spring implements AOP: JDK dynamic proxy and CGLIB proxy JDK dynamic proxy: its proxy object must be the implementation of a certain interface, which is completed by creating an implementation class of the interface during runtime The proxy of the target object; its two core classes are InvocationHandler and Proxy. CGLIB proxy: The implementation principle is similar to JDK dynamic proxy, except that the proxy object it generates during runtime is a subclass extended for the target class. CGLIB is an efficient code generation package. The bottom layer is implemented by relying on ASM (open source java bytecode editing class library) to operate bytecode. Its performance is better than JDK; the packages asm.jar and cglib.jar need to be introduced. Using AspectJ-injected aspects and @AspectJ annotation-driven aspects are actually implemented through dynamic proxies at the bottom level.

(6). AOP usage scenarios:                                                                                                                                            

##Context passing Content passing

• Error handling Error handling

• Lazy loading Lazy loading

• Debugging　　　　　　　　　　　　　　　　　 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　int �� � � tracing, profiling and monitoring �� �

• Performance optimization � Performance optimization , efficiency examine

• Persistence 　　　　　　　　　　　　　　　　　　　　　　　　　　　

• #Resource pooling 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 step                       

  #Transactions Transaction Management

• In addition, the implementation of Filter and the implementation of struts2 interceptor are both manifestations of AOP ideas.

• Recommended tutorial: "

  Java Tutorial
"

The above is the detailed content of Detailed explanation of Spring IoC and AOP principles. For more information, please follow other related articles on the PHP Chinese website!