Shulou(Shulou.com)06/02 Report--

This article mainly introduces "what are the design patterns involved in Spring". In daily operation, I believe many people have doubts about what problems Spring involves in design patterns. Xiaobian consulted various materials and sorted out simple and easy to use operation methods. I hope to help you answer the doubts about "what are the design patterns involved in Spring"! Next, please follow the small series to learn together!

The first is simple factory.

Also known as the Static Factory Method pattern, it is not one of the 23 GOF design patterns.

The essence of the simple factory pattern is that a factory class dynamically decides which product class should be created based on the parameters passed in.

BeanFactory in spring is the embodiment of simple factory pattern, according to pass a unique identifier to obtain bean object, but whether to pass parameters after the creation or pass parameters before the creation of this depends on the specific situation. The following configuration creates an itxxzBean in the HelloItxxz class.

Hello! This is Singleton Bean! value>

Hello! This is itxxzBean! value>

Second: Factory Method

New is usually used directly by the application to create new objects. In order to separate the creation and use of objects, the factory pattern is adopted, that is, the application hands over the responsibility of object creation and initialization to the factory object.

In general, applications have their own factory objects to create beans. If Spring manages the application's own factory objects, then Spring manages factory beans instead of regular beans.

Crab takes static methods in factory methods as an example to explain:

import java.util.Random;

public class StaticFactoryBean {

public static Integer createRandom() {

return new Integer(new Random().nextInt());

}

}

Create a config.xm configuration file and include it in the Spring container to manage, you need to specify the static method name through factory-method

Test:

public static void main(String[] args) {

//getBean() returns a random number when called. If factory-method is not specified, an instance of StaticFactoryBean is returned, i.e. an instance of Factory Bean XmlBeanFactory factory = new XmlBeanFactory(new ClassPathResource("config.xml")); System.out.println("I am an instance created by an IT learner:"+factory.getBean("random").toString());

}

Third: Singleton

Ensure that there is only one instance of a class and provide a global access point to it.

The singleton pattern in spring completes the second half of the sentence, providing a global access point, BeanFactory. But there is no control of singletons from the constructor level, because spring manages arbitrary java objects.

Core prompt point: The default bean under Spring is singleton, which can be passed through singleton="true".| false"or scope="? "to designate

The fourth type: adapter

In Spring's Aop, advice is used to enhance the functionality of proxied classes. Spring implements this AOP functionality using proxy patterns (1. JDK Dynamic Proxy). 2. CGLib Bytecode Generation Technology Agent.) Aspect enhancement at the method level for classes, i.e., generating proxy classes of the proxied classes, and setting interceptors before the methods of the proxy classes, enhances the functions of proxy methods by executing the heavy content of interceptors, and implements aspect-oriented programming.

Adapter class interface: Target

public interface AdvisorAdapter {

boolean supportsAdvice(Advice advice);

MethodInterceptor getInterceptor(Advisor advisor);

MethodBeforeAdviceAdapter class, Adapter

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

public boolean supportsAdvice(Advice advice) {

return (advice instanceof MethodBeforeAdvice);

}

public MethodInterceptor getInterceptor(Advisor advisor) {

MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();

return new MethodBeforeAdviceInterceptor(advice);

}

}

Fifth: Decorator

We encountered a problem in our project: our project needed to connect multiple databases, and different customers would access different databases according to their needs in each visit. We used to configure a data source in spring and hibernate frameworks, so the dataSource attribute of sessionFactory always points to this data source and is constant. All DAOs access the database through this data source when using sessionFactory. But now, due to the needs of the project, our DAO has to switch between multiple data sources when accessing sessionFactory. The problem arises: How can sessionFactory dynamically switch between different data sources according to customer needs when performing data persistence? Can we solve this problem with a few modifications within the framework of spring? Are there any design patterns that can be used?

First of all, think of configuring all dataSources in the applicationContext of spring. These dataSources may be of various types, such as different databases: Oracle, SQL Server, MySQL, etc., or different data sources: org.apache.commons.dbcp.BasicDataSource provided by apache, org.springframework.jndi.JndiObjectFactoryBean provided by spring, etc. SessionFactory then sets the dataSource property to a different data source for each request from the customer for the purpose of switching data sources.

The wrapper pattern used in spring has two manifestations on the class name: one is that the class name contains Wrapper, and the other is that the class name contains Decorator. Basically, it's all about dynamically adding some extra responsibility to an object.

Category 6: Proxy

Provides a proxy for other objects to control access to this object. Structurally similar to the Decorator pattern, but Proxy is a control, more like a restriction on functionality, while Decorator adds responsibility.

Spring Proxy patterns are embodied in aop, such as JdkDynamicAopProxy and Cglib2AopProxy.

Category 7: Observer

Defines a one-to-many dependency relationship between objects. When the state of an object changes, all dependent objects are notified and automatically updated.

A common use of the Observer pattern in spring is the implementation of the listener. Such as ApplicationListener.

Number 8: Strategy

Define a series of algorithms, package them one by one, and make them interchangeable. This pattern allows the algorithm to vary independently of the client using it.

Spring uses the Strategy pattern when instantiating objects

At this point, the study of "What are the design patterns involved in Spring" is over, hoping to solve everyone's doubts. Theory and practice can better match to help you learn, go and try it! If you want to continue learning more relevant knowledge, please continue to pay attention to the website, Xiaobian will continue to strive to bring more practical articles for everyone!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.