What is Spring framework? Introduction to Spring Framework IOC Container

This article brings you what is the Spring framework? The introduction of the Spring framework IOC container has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

1. Introduction to Spring open source framework

Spring is an open source framework and a lightweight Java development framework that emerged in 2003. Derived from some of the ideas and prototypes described by Rod Johnson in his book Expert One-On-One J2EE Development and Design. It was created to solve the complexities of enterprise application development.

Spring uses basic JavaBeans to accomplish things that were previously only possible with EJBs. However, Spring's uses are not limited to server-side development. Any Java application can benefit from Spring in terms of simplicity, testability, and loose coupling. Simply put, Spring is a lightweight Inversion of Control (IoC) and Aspect-Oriented (AOP) container framework.

The basic framework of spring mainly includes six modules: DAO, ORM, AOP, JEE, WEB, and CORE.

　

##Spring DAO: Spring provides operation support for JDBC: JdbcTemplate template tool class.

Spring ORM: Spring can be integrated with the ORM framework. For example, Spring integrates the Hibernate framework, and Spring also provides the HibernateDaoSupport tool class, which simplifies the operation of Hibernate.
Spring WEB: Spring provides support for Struts, Springmvc, and supports WEB development. At the same time, Spring itself also provides solutions based on MVC.
Spring AOP: Spring provides aspect-oriented programming, which can provide transaction management for a certain layer, such as adding transaction control to the Service layer.
Spring JEE: Support for J2EE development specifications, such as EJB.
Spring Core: Provides the creation of IOC container objects and processing of dependent object relationships.

2. IOC container and DI (Dependency injection) under Spring

IOC container: It is a container with dependency injection function. A container that can create objects. The IOC container is responsible for instantiating, locating, configuring objects in the application, and establishing dependencies between these objects. Usually a new instance is controlled by the programmer, and "inversion of control" means that the work of the new instance is not done by the programmer but is handed over to the Spring container. . In Spring, BeanFactory is the actual representative of the IOC container.

DI (Dependency injection): After the container creates the object, it handles the dependencies of the object.

Dependency injection spring injection method:

set injection method

Static factory injection method

Constructor method injection method

Based on annotations Method

1. Set injection method:

Control layer code:

private OrderServiceImp orderService;
    
public void setOrderService(OrderServiceImp orderService) {
       this.orderService = orderService;
}

Spring configuration XML file: The configuration declares that the OrderAction class has the attribute orderService. When the program is running, the instantiated orderService object will be injected using the setOrderService method.

<bean>
        <property></property>
</bean>
<bean></bean>

2. Constructor injection method:

Control layer code:

private OrderServiceImp orderService;
    
public OrderAction(OrderServiceImp orderService) {
        this.orderService = orderService;
    }

Spring configuration

XML file:

<bean>
      <constructor-arg></constructor-arg>
</bean>
<bean></bean>

3 , Annotation-based method (recommended, more convenient and less configuration)

Control layer code:

@Autowired   //@Resource
private OrderServiceImp orderService;

Service layer code:

@Service("orderService")
public class OrderServiceImp implements IOrderService {

    @Autowired
    private JavaOrderMDaoImp javaOrderMDao;

    @Autowired
    private JavaOrderDDaoImp javaOrderDDao;

    @Override
    public List<javaordermlist> findOrderM(OrderSearch search) {
        return javaOrderMDao.findJavaOrderM(search);
    }

    @Override
    public List<javaorderdlist> findOrderD(OrderSearch search) {
        return javaOrderDDao.findJavaOrderD(search);
    }

}</javaorderdlist></javaordermlist>

DAO layer code:

@Repository("javaOrderMDao")
public class JavaOrderMDaoImp extends BaseHibernateDAO<javaorderm> implements IJavaOrderMDao {...}</javaorderm>

@Repository("javaOrderDDao")
public class JavaOrderDDaoImp extendsBaseHibernateDAO<javaorderd> implements IJavaOrderDDao {...}</javaorderd>



Notes: ##  ⑴ The persistence layer DAO layer annotation Repository specifies the name, and the name declared in the Service layer must be consistent.

 ⑵ Service layer Service layer annotation The name is specified in Service, and the name declared in the control layer must be consistent.

⑶ Annotation method for injecting dependency annotations:

@Component         把对象加入ioc容器，对象引用名称是类名，第一个字母小写
@Component(“name”) 把指定名称的对象，加入ioc容器
@Repository        主要用于标识加入容器的对象是一个持久层的组件(类)
@Service           主要用于标识加入容器的对象是一个业务逻辑层的组件
@Controller        主要用于标识加入容器的对象是一个控制层的组件
@Resource          注入属性(DI), 会从容器中找对象注入到@Resource修饰的对象上
@Autowired         注入属性(DI), 会从容器中找对象注入到@Autowired修饰的对象上

# ⑷ Annotations can simplify configuration and improve development efficiency, but they are also not conducive to later maintenance.

Note: The difference between @Autowired and @Resource

The above is the detailed content of What is Spring framework? Introduction to Spring Framework IOC Container. For more information, please follow other related articles on the PHP Chinese website!