当前位置：网站首页>【无标题】

【无标题】

2022-07-01 07:54:00 【CaraYQ】

这里写目录标题

IOC

IOC操作Bean管理（XML方式）

工厂bean（FactoryBean）

一、Spring有两种类型bean，一种普通bean，另外一种工厂bean（FactoryBean）
二、普通bean：在配置文件中定义bean类型就是返回类型。例如在bean.xml中配置对象创建：

<bean id="book" class="com.atguigu.spring5.collectiontype.Book" >
	<property name="list" ref="bookList"></property>
</bean>

你这里定义的bean类型class="com.atguigu.spring5.collectiontype.Book"就是返回类型，即返回类型是Book类，我们之前讲的就是普通bean。
三、工厂bean：在配置文件定义bean类型可以和返回类型不一样。假如你定义的bean类型为class="com.atguigu.spring5.collectiontype.Book"，即Book类，但是返回的bean类型可能是其他类型。工厂bean应该怎么做：

创建类，让这个类作为工厂bean，实现接口FactoryBean，实现接口里面的方法，在实现的方法getObject中定义返回的bean类型：新建src/com/atguigu/spring5/factorybean/MyBean.java文件，代码如下：

public class MyBean implements FactoryBean<Course> {
    
    //定义返回bean，工厂bean返回的类型和定义的类型不一样全是因为在这个方法中定义了返回bean的类型
    @Override
    public Course getObject() throws Exception {
    
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
    
        return null;
    }

    @Override
    public boolean isSingleton() {
    
        return false;
    }
}

配置文件和普通bean的一样：<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>
测试：TestSpring5Demo1中的代码如下：

public class TestSpring5Demo1 {
    
    @Test
    public void test3() {
    
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean3.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }
}

bean的作用域

一、在Spring里面，可以设置创建的bean实例是单实例还是多实例，默认情况下，bean是单实例对象

二、如何设置单实例还是多实例：在spring配置文件bean标签里面有属性scope用于设置单实例还是多实例，常用的scope属性值：

singleton：默认值，表示是单实例对象
prototype：表示是多实例对象

<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
	<property name="list" ref="bookList"></property>
</bean>

以上测试代码输出：
在这里插入图片描述
三、singleton和prototype区别

singleton单实例，prototype多实例
设置scope值是singleton时，加载spring配置文件时候就会创建单实例对象，即执行ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");这行代码时就创建单实例对象了
设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建对象，在调用getBean 方法时候创建多实例对象

Course course = context.getBean("myBean", Course.class);

执行这行代码时创建对象，每次调用时创建的对象都不一样

bean的生命周期

一、生命周期：从对象创建到对象销毁的过程
二、bean生命周期

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean引用（调用set方法）
调用bean的初始化的方法（等下我们需要进行配置初始化的方法）
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（等下我们需要进行配置销毁的方法）

三、演示bean生命周期

新建src/com/atguigu/spring5/bean/Orders.java，在其中定义无参构造函数、属性及属性的set方法、bean的初始化的方法、bean的销毁的方法

public class Orders {
    
    //无参数构造
    public Orders() {
    
        System.out.println("第一步 执行无参数构造创建bean实例");
    }

    private String oname;
    public void setOname(String oname) {
    
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod() {
    
        System.out.println("第三步 执行初始化的方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod() {
    
        System.out.println("第五步 执行销毁的方法");
    }
}

新建src/bean4.xml文件，在其中进行配置，注意使用bean标签的init-method属性指定bean的初始化方法initMethod，destroy-method属性指定bean的销毁方法destroyMethod：

<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
	<property name="oname" value="手机"></property>
</bean>

测试：TestSpring5Demo1中代码如下：

public class TestSpring5Demo1 {
    
    @Test
    public void testBean3() {
    
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步 获取创建bean实例对象");
        System.out.println(orders);

        //手动让bean实例销毁
        ((ClassPathXmlApplicationContext)context).close();
    }
}

在销毁bean实例时做了个强转((ClassPathXmlApplicationContext)context).close();，如果不想做这个强转，可以这样写：

public class TestSpring5Demo1 {
    
    @Test
    public void testBean3() {
    
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步 获取创建bean实例对象");
        System.out.println(orders);
        //手动让bean实例销毁
        context.close();
    }
}

ClassPathXmlApplicationContext是ApplicationContext的子接口，在这里可以使用前者代替后者
在这里插入图片描述
四、加上bean的后置处理器，bean的生命周期有七步：

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean引用（调用set方法）
把bean实例传递bean后置处理器的方法postProcessBeforeInitialization
调用bean的初始化的方法（后面我们需要进行配置初始化的方法）
把bean实例传递bean后置处理器的方法postProcessAfterInitialization
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁的方法（后面我们需要进行配置销毁的方法）

五、演示添加后置处理器效果

创建src/com/atguigu/spring5/bean/MyBeanPost.java类，实现接口BeanPostProcessor，创建后置处理器：

public class MyBeanPost implements BeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    
        System.out.println("在初始化之前执行的方法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

在bean4.xml中配置后置处理器：

<bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
	<property name="oname" value="手机"></property>
</bean>

<!--配置后置处理器-->
<bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost"></bean>

加载配置文件时，他会创建对象和后置处理器，只要类实现了接口BeanPostProcessor，spring就会把他作为后置处理器执行，后置处理器会给当前配置文件中的所有bean实例添加后置处理器。执行前面的测试代码后输出：
在这里插入图片描述

xml自动装配

一、自动装配：根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入
我们前面向一个类中注入属性时，在配置文件中做如下配置：

<bean id="orders" class="com.atguigu.spring5.bean.Orders" >
	<property name="oname" value="手机"></property>
</bean>

我们是通过bean标签中的property标签的name属性、value属性或ref属性注入属性的，也就是你手动指定哪个属性注入哪个值，这种方式叫做手动装配
二、演示自动装配过程

新建src/com/atguigu/spring5/autowire文件夹，在其中新建两个类Dept.java、Emp.java，代码分别如下：

public class Dept {
    
    @Override
    public String toString() {
    
        return "Dept{}";
    }
}

public class Emp {
    
    private Dept dept;
    public void setDept(Dept dept) {
    
        this.dept = dept;
    }

    @Override
    public String toString() {
    
        return "Emp{" +
                "dept=" + dept +
                '}';
    }

    public void test() {
    
        System.out.println(dept);
    }
}

新建src/bean5.xml配置文件，在其中进行自动配置，bean标签中有个属性autowire，专门用来配置自动装配。autowire属性常用两个值：
（1）byName根据属性名称注入，注入值bean的id值和类属性名称一样，下面就完成了Emp类中的dept属性注入

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

说明：Emp类的dept属性名和<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>中bean的id值一致
（2）byType根据属性类型注入

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

说明：Emp类的dept属性的类型Dept类，spring会在配置文件中找到Dept类的对象<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>进行注入
注意：在使用byType根据属性类型注入时，如果类型中有重复的对象，如下面有两个Dept类的对象，此时spring压根不知道使用dept还是dept1，会报错

<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType"></bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>
<bean id="dept1" class="com.atguigu.spring5.autowire.Dept"></bean>

测试：TestSpring5Demo1.java中代码如下：

public class TestSpring5Demo1 {
    
    @Test
    public void test4() {
    
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean5.xml");
        Emp emp = context.getBean("emp", Emp.class);
        System.out.println(emp);
    }
}

引入外部属性文件

一、我们之前进行属性注入时，在配置文件中一般做如下配置，有多少个属性就要写多少个property标签，当类发生变化时，还需要改配置文件，那么我们可以把相关值、固定值放在一个其他文件中，然后将其他文件引入配置文件，配置文件读取其他文件的内容

<bean id="orders" class="com.atguigu.spring5.bean.Orders" >
	<property name="oname" value="手机"></property>
</bean>

二、以数据库配置文件为例，

直接配置数据库信息：
（1）引入连接池依赖jar包：将下列jar包复制到lib文件夹下

引入进来：

新建src/bean6.xml配置文件，在其中直接配置连接池：

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
	<!--数据库驱动-->
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<!--数据库地址-->
	<property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
	<!--连接数据库的用户名-->
	<property name="username" value="root"></property>
	<!--数据库密码-->
	<property name="password" value="root"></property>
</bean>

引入外部属性文件配置数据库连接池
（1）创建外部属性文件src/jdbc.properties（注意要是properties格式文件），写数据库信息

// 为了防止冲突，属性名都加前缀prop.
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root

（2）把外部 properties 属性文件引入到 spring 配置文件中
首先引入 context 名称空间
在这里插入图片描述
然后使用context:property-placeholder标签引入外部属性文件，context:property-placeholder有一个location属性，用来指定要引入的外部文件的路径，因为jdbc.properties在src文件夹下，所以可以写作classpath:jdbc.properties。最后使用${外部文件的键名}表达式配置连接池

<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
	<property name="driverClassName" value="${prop.driverClass}"></property>
	<property name="url" value="${prop.url}"></property>
	<property name="username" value="${prop.userName}"></property>
	<property name="password" value="${prop.password}"></property>
</bean>

IOC操作Bean管理（注解方式）

创建对象

一、什么是注解

注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
使用注解，注解作用在类上面，方法上面，属性上面
使用注解目的：简化 xml 配置

二、Spring针对Bean管理中创建对象提供注解，下面四个注解功能是一样的，都可以用来创建bean实例

@Component：spring容器中提供的普通组件
@Service：用于业务逻辑层或service层
@Controller：用于web层
@Repository：用于dao层或持久层

三、基于注解方式实现对象创建，新建项目spring5_demo3

引入依赖：将下面这个jar包复制到lib文件夹下

在项目中导入：
开启组件扫描，也就是告诉spring我现在在哪个类中要加上注解，让spring去扫描这个类，看类上面有没有注解，有注解就创建对象，即指定spring要扫描的位置
（1）在配置文件中引入名称空间

（2）开启组件扫描：
使用context:component-scan标签的base-package属性指定扫描哪个包下的内容，其属性值是包名：<context:component-scan base-package="com.atguigu.spring5.dao"></context:component-scan>
如果扫描多个包，多个包使用逗号隔开：<context:component-scan base-package="com.atguigu.spring5.dao, com.atguigu.spring5.service"></context:component-scan>
或者扫描多个包的上层目录，即他们的共同的父目录：<context:component-scan base-package="com.atguigu.spring5"></context:component-scan>
（3）创建类，在类上面添加创建对象注解@Component(value = "这个组件的标识名，相当于bean标签的id属性值")，value属性值可以省略不写，省略不写使用默认值，默认值是首字母小写的类名称UserService -- userService

@Component(value = "userService")  //<bean id="userService" class=".."/>
public class UserService {
    
    public void add() {
    
        System.out.println("service add......."+name);
        userDao.add();
    }
}

测试：新建src/com/atguigu/spring5/testdemo/TestSpring5Demo1.java文件，测试代码：

public class TestSpring5Demo1 {
    
    @Test
    public void testService1() {
    
        ApplicationContext context
                = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }
}

四、基于注解方式实现对象创建执行过程：

加载配置文件ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
配置文件中只开启了组件扫描：<context:component-scan base-package="com.atguigu"></context:component-scan>，这句话一生效，spring就知道你要用注解方式实现对象创建，他就去你指定的包中找到包中的所有类，若类上面有相关的注解，他就根据注解创建对象。
UserService userService = context.getBean("userService", UserService.class);对象创建后调用包做输出

组件扫描配置

之前我们使用<context:component-scan base-package="com.atguigu"></context:component-scan>这种配置，spring会扫描com.atguigu包下的所有类，但是有些类是没有必要扫的，那么我们可以对组件扫描进行更精细化的配置。

给context:component-scan标签设置use-default-filters="false"属性，表示现在不使用默认filter，自己配置filter，即不扫描com.atguigu包下的所有类，扫描com.atguigu包下我们指定的类。context:include-filter标签用于设置扫描哪些内容，他的type属性表明是注解扫描，expression属性用于指定扫描哪些注解

<!--只扫描com.atguigu包中带Controller注解的类-->
<context:component-scan base-package="com.atguigu" use-default-filters="false">
	<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

使用<context:component-scan base-package="com.atguigu"></context:component-scan>配置扫描包所有内容，然后在context:component-scan标签中使用context:exclude-filter标签设置哪些内容不进行扫描

<!--不扫描com.atguigu包中带Controller注解的类-->
<context:component-scan base-package="com.atguigu">
	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

属性注入

新建src/com/atguigu/spring5/dao文件夹，在其中创建UserDao.java及其实现类UserDaoImpl.java，代码如下：

public interface UserDao {
    
    public void add();
}

public class UserDaoImpl implements UserDao {
    
    @Override
    public void add() {
    
        System.out.println("dao add.....");
    }
}

@Autowired：根据属性类型进行自动装配

我们现在想实现在service中调用dao中的方法：

创建service和dao对象，在service和dao类添加创建对象注解：在service的类上添加@Service注解，在UserDaoImpl上添加@Repository注解
在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解
（1）在属性上面使用@Autowired根据类型进行注入：

@Service
public class UserService {
    
    //定义dao类型属性,不需要添加set方法,添加注入属性注解
    @Autowired  //根据类型进行注入
    private UserDao userDao;

    public void add() {
    
        System.out.println("service add......."+name);
        userDao.add();
    }
}

@Qualifier：根据名称进行注入

一个类型有很多个实现类，此时用@Autowired根据类型注入就没法注入，spring不知道用哪个实现类，现在我们使用@Qualifier根据名称进行注入：@Qualifier(value = "实现类的注入名称")

在UserDaoImpl类上使用@Repository注解设置组件标识名，相当于bean标签的id属性值，不设置则使用默认值，默认值是首字母小写的类名称

@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao {
    
    @Override
    public void add() {
    
        System.out.println("dao add.....");
    }
}

在UserService中使用@Qualifier注解进行注入，在@Qualifier中使用value属性指定组件标识名，也就是说@Qualifier中的value属性值和@Repository中的value属性值一致，代码如下：

@Service
public class UserService {
    
    //定义dao类型属性,不需要添加set方法,添加注入属性注解
    @Qualifier(value = "userDaoImpl1") //根据名称进行注入
    private UserDao userDao;

    public void add() {
    
        System.out.println("service add......."+name);
        userDao.add();
    }
}