spring的ioc是什么模式

转载

我心依旧 2024-11-13 12:38:35

文章标签 spring的ioc是什么模式 spring xml User 文章分类 架构后端开发

最新理解
IOC是整个Spring的核心，AOP是在IOC实现的基础上的锦上添花。
IOC是将目标类作为BEAN交给Spring去管理，AOP是在拿到BEAN对象的时候，提前执行、环绕执行、最终执行的方法。

一、Spring概述

Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。

一.Spring的优势

1、方便解耦，简单开发

通过Spring提供的Ioc容器，可以将对象间的依赖关系交由Spring进行控制，避免过度程序耦合，可以更加专注于上层的应用。

2、AOP变成的支持

通过Spring的AOP功能，方便进行切面的编程，许多不容易实现的功能可以使用AOP进行轻松的实现。

3、声明式事务的支持

例如@Transactional
通过声明的方式灵活地进行事务管理，提高开发效率和质量。

4、方便程序的测试

这块我还没有体会

5、方便集成各种优秀框架

可以集成其他的框架

6、降低JAVAEE API的使用难度

Spring对JDBC、JAVAMAIL和远程调用进行了封装，降低了这些API的使用难度。

二、IOC（Inversion of control，控制反转）

一.什么是IOC

IOC是一个技术思想，而不是一个技术实现。

描述的是：JAVA对象创建和管理的问题
例：需要在类A中调用类B的非静态方法

传统方式：在类A中NEW一个类B的对象（A依赖于B）。
IOC方式：不需要自己去NEW对象，而是从容器（IOC容器）中获取，不需要自己创建。

在IOC方式下，类A丧失了创建和管理对象的权力，得到一个福利是不用考虑对象的创建和管理，因为容器会帮我们创建和管理好。

二.什么是IOC容器

Spring提供了IOC容器的两种实现方式：（两个接口）
这两个接口的作用是相似的，都能加载XML文件通过工厂的过程去创建对象
主类

import domain.User;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestDemo {
    public static void main(String[] args) {
        //BeanFactory beanFactory = new ClassPathXmlApplicationContext("bean.xml");
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        User user = applicationContext.getBean("User", User.class);
        user.setName("麟之");
        user.setAge(1);
        System.out.println(user.toString());
    }
}

User

package domain;

public class User {

    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

XML配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd" >
    <bean id="User" name="User" class="domain.User" ></bean>
</beans>

1、BeanFactory

BeanFactory是spring的原始接口，针对原始结构的实现类功能比较单一，BeanFactory接口实现的容器，特点是在每次获取对象时才会创建对象。
BeanFactory在启动的时候不会去实例化Bean，中有从容器中拿Bean的时候才会去实例化；
在这一步的时候才开始创建对象

User user = applicationContext.getBean("User", User.class);

2、ApplicationContext

继承了BeanFactory接口，拥有BeanFactory的全部功能，并且扩展了很多高级特性.

国际化（MessageSource）
访问资源，如URL和文件（ResourceLoader）
载入多个（有继承关系）上下文，使得每一个上下文都专注于一个特定的层次，比如应用的web层
消息发送、响应机制（ApplicationEventPublisher）
AOP（拦截器）

ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化；

ApplicationContext 包含 BeanFactory 的所有特性，通常推荐使用前者。但是也有一些限制情形，比如移动应用内存消耗比较严苛，在那些情景中，使用更轻量级的 BeanFactory 是更合理的。绝大多数的情况下ApplicationContext是首选。

三.IOC操作Bean管理（XML配置）

1、Bean管理是什么？

Bean管理指的是两个操作，创建对象和注入属性。

2、XML配置文件配置基本信息

(1).基于XML方式创建对象

在Spring配置文件中，使用bean标签，并在里面添加对应的属性就可以实现对象的创建。
Bean中有很多的属性

ID属性：等同于别名，唯一的标识。
Class属性：创建对象的类的全路径
Name属性：用来为id创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。
autowire：自动装配，默认为true
lazy-init：懒加载，默认为default，用来定义这个Bean是否实现懒初始化。如果为“true”，它将在BeanFactory启动时初始化所有的SingletonBean。反之，如果为“false”,它只在Bean请求时才开始创建SingletonBean。
scope：scope属性表示bean的作用范围，scope有4个值：
singleton：表示整个IOC容器共享一个Bean，也就是说每次说每次通过getBean获取的bean都是同一个。
prototype：每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。
request：每次HTTP请求将会生成各自的bean实例
session：每次会话请求对应一个bean实例
singleton和prototype经常使用，request和session基本不使用。

(2).基于XML方式注入属性

XML注入方式有两种：普通的SET注入和带参构造注入
普通SET注入

package domain;

public class Stu {
    private Integer id;
    private String name;
    private  String stuClass;

    public void setId(Integer id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setStuClass(String stuClass) {
        this.stuClass = stuClass;
    }

    public Integer getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getStuClass() {
        return stuClass;
    }

    public Stu(Integer id, String name, String stuClass) {
        this.id = id;
        this.name = name;
        this.stuClass = stuClass;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", stuClass='" + stuClass + '\'' +
                '}';
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd" >
    <bean id="User" name="User" class="domain.User" >
        <property name="name" value="麟之"></property>
        <property name="age" value="1"></property>
    </bean>
</beans>

带参构造注入

package domain;

public class Stu {
    private Integer id;
    private String name;
    private  String stuClass;
    public Stu(Integer id, String name, String stuClass) {
        this.id = id;
        this.name = name;
        this.stuClass = stuClass;
    }
    @Override
    public String toString() {
        return "Stu{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", stuClass='" + stuClass + '\'' +
                '}';
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd" >
    <bean id="Stu"  class="domain.Stu" >
        <constructor-arg name="id" value="1"></constructor-arg>
        <constructor-arg name="name" value="麟之"></constructor-arg>
        <constructor-arg name="stuClass" value="1年纪"></constructor-arg>
    </bean>
</beans>

(3).XML注入其他类型属性

设置NULL值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="User" name="User" class="domain.User">
        <property name="name" value="麟之"></property>
        <property name="age">
            <null></null>
        </property>
    </bean>
</beans>

包含特殊符号
可以进行转义或者使用CDATA

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="User" name="User" class="domain.User">
        <property name="name">
            <value>
                <![CDATA[<<麟之>>]]>
            </value>
        </property>
        <property name="age" value="1">
        </property>
    </bean>
</beans>

(4).XML注入外部bean

package controller;

import service.userService;

public class userController {

    //创建userService类型，并生成SET方法
    private userService userservice;

    public void setUserservice(userService userservice) {
        this.userservice = userservice;
    }

    public void addUser() {
        userservice.addUser();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userServiceImpl" class="service.userServiceImpl"></bean>

    <bean id="userController" class="controller.userController">
        <!--将userServiceImpl注入到userController中-->
        <property name="userservice" ref="userServiceImpl"></property>
    </bean>
</beans>

package service;
public interface userService {
    void addUser();
}
package service;
public class userServiceImpl implements userService{
    public void addUser() {
        System.out.println("添加用户");
    }
}

(5).XML注入内部bean和级联赋值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--注入内部BEAN-->
    <bean id="Stu" class="domain.Stu">
        <!--普通属性-->
        <property name="id" value="1"></property>
        <property name="name" value="麟之"></property>
        <!--设置对象类型属性-->
        <property name="school">
            <bean id="School" class="domain.School">
                <property name="ID" value="110"></property>
                <property name="NAME" value="GXEZ"></property>
            </bean>
        </property>
    </bean>
</beans>

也可以这样写
    <bean id="Stu" class="domain.Stu">
        <!--普通属性-->
        <property name="id" value="1"></property>
        <property name="name" value="麟之"></property>
        <!--设置对象类型属性-->
        <property name="school" ref="School"></property>
    </bean>
    <bean id="School" class="domain.School">
        <property name="ID" value="110"></property>
        <property name="NAME" value="GXEZ"></property>
    </bean>

package domain;

public class School {
    private Integer ID;
    private String NAME;

    public void setID(Integer ID) {
        this.ID = ID;
    }

    public void setNAME(String NAME) {
        this.NAME = NAME;
    }
}

package domain;

public class Stu {

    private Integer id;
    private String name;
    private  String stuClass;
    //对象形式表示
    private School school;
    public void setId(Integer id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setStuClass(String stuClass) {
        this.stuClass = stuClass;
    }
    public void setSchool(School school) {
        this.school = school;
    }
    @Override
    public String toString() {
        return "Stu{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", stuClass='" + stuClass + '\'' +
                ", school=" + school +
                '}';
    }
}

(6).XML注入集合属性

注入数组类型
注入LIST集合类型
注入MAP集合类型
注入SET集合类型
这些我写在一个XML配置文件中了

package domain;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Student {
    private Integer id;
    private String Name;
    private String[] courses;

    private List<String> listTest;

    private Map<String, String> mapTest;

    private Set<String> setTest;

    public void setId(Integer id) {
        this.id = id;
    }
    public void setName(String name) {
        Name = name;
    }
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setListTest(List<String> listTest) {
        this.listTest = listTest;
    }
    public void setMapTest(Map<String, String> mapTest) {
        this.mapTest = mapTest;
    }
    public void setSetTest(Set<String> setTest) {
        this.setTest = setTest;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", Name='" + Name + '\'' +
                ", courses=" + Arrays.toString(courses) +
                ", listTest=" + listTest +
                ", mapTest=" + mapTest +
                ", setTest=" + setTest +
                '}';
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--集合类型属性注入-->
    <bean id="Student" class="domain.Student">
        <property name="id" value="1"></property>
        <property name="name" value="麟之"></property>
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>数学</value>
                <value>ENGLISH</value>
            </array>
        </property>
        <property name="listTest">
            <list>
                <value>贝塔</value>
                <value>丹儿子</value>
            </list>
        </property>

        <property name="mapTest">
            <map>
                <entry key="KEY1" value="1"></entry>
                <entry key="KEY2" value="2"></entry>
                <entry key="KEY3" value="3"></entry>
            </map>
        </property>
        <!--set类型属性注入-->
        <property name="setTest">
            <set>
                <value>你</value>
                <value>好</value>
                <value>啊</value>
            </set>
        </property>
    </bean>
</beans>

(7).XML注入对象集合属性

package domain;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Student {
    private Integer id;
    private String Name;
    private School[] courses;

    private List<School> listTest;

    private Map<Integer, School> mapTest;

    private Set<School> setTest;

    public void setId(Integer id) {
        this.id = id;
    }
    public void setName(String name) {
        Name = name;
    }
    public void setCourses(School[] courses) {
        this.courses = courses;
    }
    public void setListTest(List<School> listTest) {
        this.listTest = listTest;
    }
    public void setMapTest(Map<Integer, School> mapTest) {
        this.mapTest = mapTest;
    }
    public void setSetTest(Set<School> setTest) {
        this.setTest = setTest;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", Name='" + Name + '\'' +
                ", courses=" + Arrays.toString(courses) +
                ", listTest=" + listTest +
                ", mapTest=" + mapTest +
                ", setTest=" + setTest +
                '}';
    }
}
package domain;
public class School {
    private Integer ID;
    private String NAME;
    public void setID(Integer ID) {
        this.ID = ID;
    }
    public void setNAME(String NAME) {
        this.NAME = NAME;
    }
    @Override
    public String toString() {
        return "School{" +
                "ID=" + ID +
                ", NAME='" + NAME + '\'' +
                '}';
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--集合类型属性注入-->
    <bean id="Student" class="domain.Student">
        <property name="id" value="1"></property>
        <property name="name" value="麟之"></property>
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <ref bean="School1"></ref>
                <ref bean="School2"></ref>
            </array>
        </property>
        <property name="listTest">
            <list>
                <ref bean="School1"></ref>
            </list>
        </property>

        <property name="mapTest">
            <map>
                <entry key="1" value-ref="School1"></entry>
            </map>
        </property>
        <!--set类型属性注入-->
        <property name="setTest">
            <set>
                <ref bean="School1"></ref>
                <ref bean="School2"></ref>
            </set>
        </property>
    </bean>

    <bean id="School1" class="domain.School">
        <property name="ID" value="1"></property>
        <property name="NAME" value="lqyz"></property>
    </bean>

    <bean id="School2" class="domain.School">
        <property name="ID" value="2"></property>
        <property name="NAME" value="gxrz"></property>
    </bean>
</beans>

3、工厂Bean(FactoryBean)

Spring中有两种类型的Bean，一种是普通的bean，另一种是工厂bean(FactoryBean)

1.普通Bean（定义什么类型返回什么类型）

在bean标签中定义Class中的类型，返回的就是该类型。

2.工厂Bean（定义类型与返回类型不一定相同）

在bean标签中定义Class中的类型，返回的可能是其他类型。

3.工厂Bean创建步骤

(1).创建类

让该类作为工厂Bean，并实现FactoryBean接口

(2).实现FactoryBean接口的方法

实现FactoryBean接口的方法

4.代码演示

import domain.Student;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean6.xml");
        Student student = applicationContext.getBean("MyBean", Student.class);
        System.out.println(student.toString());
    }
}

package factoryBean;

import domain.Student;
import org.springframework.beans.factory.FactoryBean;

public class MyBean implements FactoryBean<Student> {
    @Override
    public Student getObject() throws Exception {
        Student student = new Student();
        student.setId(1);
        student.setName("麟之");
        return  student;
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
    @Override
    public boolean isSingleton() {
        return false;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="MyBean" class="factoryBean.MyBean"></bean>
</beans>

4、Bean的作用域

在Spring中，可以设置创建Bean实例是单实例还是多实例。
默认情况下是单例的。
设置Spring是单实例还是多实例对象
scope：scope属性表示bean的作用范围，scope有4个值：
singleton：表示整个IOC容器共享一个Bean，也就是说每次说每次通过getBean获取的bean都是同一个。
prototype：每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。
request：每次HTTP请求将会生成各自的bean实例
session：每次会话请求对应一个bean实例
singleton和prototype经常使用，request和session基本不使用。

5、Bean的生命周期（从对象创建到销毁的过程）

通过构造器创建Bean实例（无参构造）
为Bean的属性设置值和对其他Bean引用（调用SET方法）
添加后置处理器之后，初始化之前有一个操作。
调用Bean的初始化方法（需要进行配置）
添加后置处理器之后，初始化之后有一个操作。
bean对象可以被获取到
当容器关闭的时候，调用Bean的销毁方法。（需要进行配置）

1.Bean生命周期代码演示（未添加后置处理器）

package bean;

public class Orders {
    private Integer id;
    private String orderName;

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", orderName='" + orderName + '\'' +
                '}';
    }
    
    public Orders() {
        System.out.println("第1步，无参构造，创建Bean实例");
    }

    public void setId(Integer id) {
        System.out.println("第2步，SET设置属性，id");
        this.id = id;
    }

    public void setOrderName(String orderName) {
        System.out.println("第2步，SET设置属性，orderName");
        this.orderName = orderName;
    }

    //创建初始化方法
    public void initMethod() {
        System.out.println("第3步，初始化，initMethod");
    }

    //创建销毁方法
    public void destoryMethod() {
        System.out.println("第5步，销毁，destoryMethod");
    }
}

import bean.Orders;
import domain.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext  classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean7.xml");

        Orders orders = classPathXmlApplicationContext.getBean("Orders", Orders.class);
        System.out.println("第4步，获取创建Bean的实例对象");
        System.out.println(orders.toString());
        //手动让Bean销毁
        classPathXmlApplicationContext.close();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="Orders" class="bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
        <property name="id" value="110"></property>
        <property name="orderName" value="订单"></property>
    </bean>
</beans>

2.Bean生命周期代码演示（添加后置处理器）

package bean;

public class Orders {
    private Integer id;
    private String orderName;

    @Override
    public String toString() {
        return "Orders{" +
                "id=" + id +
                ", orderName='" + orderName + '\'' +
                '}';
    }
    public Orders() {
        System.out.println("第1步，无参构造，创建Bean实例");
    }
    public void setId(Integer id) {
        System.out.println("第2步，SET设置属性，id");
        this.id = id;
    }
    public void setOrderName(String orderName) {
        System.out.println("第2步，SET设置属性，orderName");
        this.orderName = orderName;
    }
    //创建初始化方法
    public void initMethod() {
        System.out.println("第4步，初始化，initMethod");
    }

    //创建销毁方法
    public void destoryMethod() {
        System.out.println("第7步，销毁，destoryMethod");
    }
}
package bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class OrderPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第3步，初始化之前的操作");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第5步，初始化之后的操作");
        return bean;
    }
}
import bean.Orders;
import domain.Student;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext  classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean7.xml");

        Orders orders = classPathXmlApplicationContext.getBean("Orders", Orders.class);
        System.out.println("第6步，获取创建Bean的实例对象");
        System.out.println(orders.toString());
        //手动让Bean销毁
        classPathXmlApplicationContext.close();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="Orders" class="bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
        <property name="id" value="110"></property>
        <property name="orderName" value="订单"></property>
    </bean>
    <!--配置后置处理器，会给该xml配置文件中所有的BEAN都添加后置处理器-->
    <bean id="OrderPost" class="bean.OrderPost" ></bean>
</beans>

6、XML配置自动装配（根据属性名称或者属性类型自动将匹配的属性值进行注入）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="123" class="autowire.Dept">
        <property name="deptId" value="1"></property>
        <property name="deptName" value="test"></property>
    </bean>
<!--    <!–根据类型自动装配，相同类型的Bean不能定义多个–>-->
<!--    <bean id="Emp" class="autowire.Emp" autowire="byType"></bean>-->
    <!--根据名称自动装配，要和private  Dept dept;-->
    <bean id="Emp" class="autowire.Emp" autowire="byName">
        <property name="id" value="1"></property>
        <property name="dept" ref="123"></property>
    </bean>
</beans>

7、XML配置引入外部文件

1.直接进行配置Druid数据库连接池

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverclass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
</beans>

2.引入外部属性文件配置数据库连接池

将外部的properties属性文件引入到Spring配置文件中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverclass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
</beans>

jdbc.driverclass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=xxxx

四、IOC操作Bean管理（注解配置）

使用注解的目的是简化XML配置，毕竟XML配置真的挺繁琐的。

一、Spring针对Bean管理中创建对象提供的注解

@Component、@Service、@Controller、@Repository，这四个注解是等价的，都可以创建Bean实例，但是一般写的地方不同
@Component：普通的，不知道写啥就写这个
@Service：Service层（业务逻辑层）
@Controller：用在Controller中（WEB层）
@Repository：用在DAO层

二、基于注解方式实现对象的创建

1、引入依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.9.RELEASE</version>
        </dependency>

2、开启组件扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启组件扫描-->
    <context:component-scan base-package="annocation"></context:component-scan>
</beans>

3、创建类

value默认值是类名称，首字母小写，也可以写在上面。

package annocation.service;

import org.springframework.stereotype.Service;
//value等价于 bean中的ID
@Service(value = "orderService")
public class OrderService {
    public void add() {
        System.out.println("OrderService.add");
    }
}

4、注解扫描的细节设置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启组件扫描-->
    <!--use-default-filters="false"表示不使用默认的FILTER，而是自动配置-->
    <context:component-scan base-package="annocation" use-default-filters="false">
        <!--意思是，在annocation只扫描带有Controller注解的类-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

5、注解属性的注入

@Autowired
根据属性类型进行自动装配
@Autowired(required=true)，其实默认就是,表示注入的时候，该bean必须存在，否则就会注入失败。
@Autowired(required=false)：表示忽略当前要注入的bean，如果有直接注入，没有跳过，不会报错。
@Qualifier
根据属性名称进行注入，如果要使用，必须和@Autowired一起使用。
@Resource
可以根据类型注入，也可以根据名称注入。
@Value
值类型注入

@Value(value="麟之")
private String name;

6、纯注解开发

1.创建配置类，替换XML的配置文件

import annocation.service.OrderService;

import config.SpringConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestDemo {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);

        OrderService orderService = applicationContext.getBean("OrderService", OrderService.class);
        orderService.add();
    }

package config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration//作为配置类，替换XML文件
@ComponentScan(basePackages = "annocation")//设置扫描路径
public class SpringConfig {

}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：arm架构安装单价版本k8s

下一篇：redis 队列 java leftpush

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯