Spring IoC
Bean 管理
XML 方式创建 Bean 对象
XML 方式注入属性
XML 方式注入特殊值
FactoryBean
Bean 作用域
bean 生命周期
xml 自动装配
1. 根据属性名称自动注入
2. 根据属性类型自动注入
外部属性文件
1. 直接配置数据库信息
2. 外部属性文件配置数据库连接池
  1. 增加 jdbc.properties 文件，保存数据库信息
  2. Spring 配置文件
注解方式管理 Bean
注解方式实现属性注入
完全注解开发
1. 注解配置类
2. 测试方法

¶Spring IoC

Spring 提供 IoC 容器实现两种方式（两个接口）：

BeanFactory
IoC 容器基本实现，是 Spring 内部使用接口
不提倡开发人员进行使用
. 加载配置文件时不会创建对象，获取（使用）对象时才会创建对象
ApplicationContext
BeanFactory的子接口
推荐开发人员使用
. 加载配置文件时，就会将配置文件中的对象进行创建

❓为什么读取配置文件时，就创建对象？

服务端，为了能够更快速高效的为用户提供服务；需要使用的对象，最好启动服务时就创建，以免出现请求时，对象才开始创建的现象

¶ApplicationContext 主要实现类

实现类	区别
ClassPathXmlApplicationContext	读取类路径下的 XML 格式的配置文件
FileSystemXmlApplicationContext	文件系统中的 XML 格式的配置文件

ApplicationContext继承体系

¶ConfigurableApplicationContext

✨ConfigurableApplicationContext类

是ApplicationContext的子接口
refresh()和close()让ApplicationContext具有启动、关闭和刷新上下文的能力

¶WebApplicationContext

✨专门为 WEB 应用而准备，允许从相对于 WEB 根目录的路径中完成初始化工作

¶Bean 管理

✨IoC 中进行 Bean 管理，主要指的时两个操作：

Spring 创建 Bean 对象
Spring 注入属性

Bean 管理操作存在两种方式：

基于 XML 配置文件方式实现（新手）
基于注解方式实现（老鸟）

¶XML 方式创建 Bean 对象

Spring 项目的构建至少需要如下几个包

spring-beans
spring-context
spring-core
spring-expression

¶创建 Java Bean

public class User {
 private String name;
 private Integer age;

 public void add() {
  System.out.println("from User's add method...");
 }
}

¶Spring 配置文件

<?xml version="0" encoding="UTF-?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www..org/0XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="user" class="com.pineapple_man.spring.User"></bean>
</beans>

✨Spring 配置文件特点

使用<bean>标签，实现对象创建
id属性：唯一标识
class属性：创建类的全路径

🎶Spring 创建对象时，默认执行无参数构造方法完成对象创建

¶代码测试

public class UserTest {
 @Test
 public void add() {
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beanxml");
        //getBean()的第一个参数是 beanxml 中 bean 的 id
  User user = applicationContext.getBean("user", User.class);
  user.add();
 }
}

¶XML 方式注入属性

对于大项目通常使用注解方式，XML 方式使得项目复杂并且难以管理，但是便于学习

XML方式注入属性

¶set 方法注入

创建类，定义属性

public class User {
 private String name;
 private Integer age;

 public void add() {
  System.out.println("from User's add method...");
 }

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

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

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

在 Spring 配置文件配置对象创建，配置属性注入

<bean id="user" class="com.pineapple_man.spring.User">
 <property name="age" value=""></property>
 <property name="name" value="张三丰"></property>
</bean>

🎶<property>标签中属性值含义

name类里面属性名称
value向属性注入的值

¶有参构造进行注入

创建有参数构造

public class User {
 private String name;
 private Integer age;

 public User(String name, Integer age) {
  this.name = name;
  this.age = age;
 }

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

在 Spring 配置文件中进行配置

<bean id="user" class="com.pineapple_man.spring.User">
 <constructor-arg name="age" value=""></constructor-arg>
 <constructor-arg name="name" value="达摩老祖"></constructor-arg>
</bean>

¶p 名称空间注入

添加 p 名称空间到配置文件中

<?xml version="0" encoding="UTF-?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.worg/0XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

进行属性注入

1	<bean id="user" class="com.pineapple_man.spring.User" p:age=" p:name="超哥"></bean>

¶XML 方式注入特殊值

主要是通过 xml 注入其他类型的数据

¶注入 null

<bean id="user" class="com.pineapple_man.spring.User">
 <property name="age" value=""></property>
 <property name="name">
  <null></null>
 </property>
</bean>

¶注入属性包含特殊符号

存在两种方式:

使用转移字符(&lt,&gt)
将带特殊符号内容写到 CDATA 中

<bean id="user" class="com.pineapple_man.spring.User">
 <property name="age" value=""></property>
 <property name="name">
  <value><![CDATA[<<南京>>]]></value>
 </property>
</bean>

¶注入外部 bean

在Service类的内部，调用了dao类方法

public class UserService {
 UserDao dao = new UserImpl();

 public void setDao(UserDao dao) {
  this.dao = dao;
 }

 public void update() {
  System.out.println("from service update method.");
  dao.update();
 }
}

public class UserImpl implements UserDao {
 @Override
 public void update() {
  System.out.println("from userimple update method");
 }
}

配置文件中进行配置

<bean id="userService" class="com.pineapple_man.spring.service.UserService">
 <property name="dao" ref="userDao"/>
</bean>
<bean id="userDao" class="com.pineapple_man.spring.dao.impl.UserImpl"></bean>

✨ref属性：只想另一个javaBean的id

¶注入内部 bean

书写对应实体类

public class Class {
 private String name;
 private int stuentsNumber;

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

 public void setStuentsNumber(int stuentsNumber) {
  this.stuentsNumber = stuentsNumber;
 }

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

public class Student {
 private String name;
 private Integer age;
 private String gender;
 //一个学生属于一个班级
 private Class aClass;
 //内部注入，不需要getter方法
 public void setaClass(Class aClass) {
  this.aClass = aClass;
 }

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

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

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

 public void setGender(String gender) {
  this.gender = gender;
 }

 public Student(String name, Integer age, String gender) {
  this.name = name;
  this.age = age;
  this.gender = gender;
 }
}

内部 bean 配置

<bean id="student" class="com.pineapple_man.spring.bean.Student">
 <constructor-arg name="name" value="Tony"></constructor-arg>
 <constructor-arg name="age" value=""></constructor-arg>
 <constructor-arg name="gender" value="male"></constructor-arg>
 <property name="aClass">
  <bean id="class" class="com.pineapple_man.spring.bean.Class">
   <property name="name" value="S00"></property>
   <property name="stuentsNumber" value=""></property>
  </bean>
 </property>
</bean>

¶级联赋值

级联赋值，用于向一个对象中注入另一个对象

¶注入外部 bean 方式

<bean id="student" class="com.pineapple_man.spring.bean.Student">
 <constructor-arg name="name" value="Tony"></constructor-arg>
 <constructor-arg name="age" value=""></constructor-arg>
 <constructor-arg name="gender" value="male"></constructor-arg>
 <!--级联赋值-->
    <property name="aClass" ref="class"></property>
</bean>
<bean id="class" class="com.pineapple_man.spring.bean.Class">
 <property name="name" value="S00"></property>
 <property name="stuentsNumber" value=""></property>
</bean>

¶指定属性注入

<bean id="student" class="com.pineapple_man.spring.bean.Student">
 <constructor-arg name="name" value="Tony"></constructor-arg>
 <constructor-arg name="age" value=""></constructor-arg>
 <constructor-arg name="gender" value="male"></constructor-arg>
 <!--级联赋值-->
    <property name="aClass" ref="class"></property>
 <property name="aClass.name" value="S00"/>
</bean>
<bean id="class" class="com.pineapple_man.spring.bean.Class">
</bean>

🎶ref指定的类需要在当前类中存在setter和getter方法

¶注入集合属性

对集合类属性注入

¶常见类型注入

创建包含集合属性的类，拥有数组、List、Map、Set属性

public class Student {
 private String name;
 private Integer age;
 private String gender;
 private String[] courses;
 private List<String> list;
 private Map<String, String> map;
 private Set<String> set;

 public void setSet(Set<String> set) {
  this.set = set;
 }

 public void setCourses(String[] courses) {
  this.courses = courses;
 }

 public void setList(List<String> list) {
  this.list = list;
 }

 public void setMap(Map<String, String> map) {
  this.map = map;
 }
 public Student() {
 }
}

配置文件

<bean id="student" class="com.pineapple_man.spring.bean.Student">
    <property name="courses">
        <array>
            <value>语文</value>
            <value>数学</value>
            <value>英语</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>语文</value>
            <value>数学</value>
            <value>英语</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>MySQL</value>
            <value>ELK</value>
        </set>
    </property>
    <property name="score">
        <map>
            <entry key="语文" value=""></entry>
            <entry key="数学" value="0"></entry>
        </map>
    </property>
</bean>

¶bean 类型注入

<bean id="user class="com.pineapple_man.spring.bean.User">
 <property name="name" value="超哥"></property>
 <property name="age" value=""></property>
</bean>
<bean id="user class="com.pineapple_man.spring.bean.User">
 <property name="name" value="龙哥"></property>
 <property name="age" value=""></property>
</bean>
<bean id="student" class="com.pineapple_man.spring.bean.Student">
 <!--注入list集合类型，值是对象-->
    <property name="teachers">
     <list>
         <ref bean="user></ref>
            <ref bean="user></ref>
  </list>
 </property>
</bean>

public class Student {
   private List<User> teachers;

   public void setTeachers(List<User> teachers) {
      this.teachers = teachers;
   }
}

¶提取共同代码

在 Spring 配置文件中引入名称空间util

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.worg/0XMLSchema-instance"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
</beans>

使用utils标签完成 list 集合公共部分的提取

<bean id="user class="com.pineapple_man.spring.bean.User">
 <property name="name" value="龙哥"></property>
</bean>
<bean id="user class="com.pineapple_man.spring.bean.User">
 <property name="name" value="超哥"></property>
</bean>
<util:list id="teacherList">
 <ref bean="user></ref>
    <ref bean="user></ref>
</util:list>
<bean id="stu class="com.pineapple_man.spring.bean.Student">
 <property name="teachers" ref="teacherList"></property>
</bean>

¶FactoryBean

✨Spring 有两种类型bean：普通bean和FactoryBean

普通 bean：配置文件中定义bean类型就是返回类型
工厂 bean：配置文件定义bean类型可以和返回类型不同

⛵FactoryBean 使用步骤：

创建工厂 bean 类，实现FactoryBean接口
实现接口中的方法，在实现的方法中返回声明的 bean 类型

public class MyBean implements FactoryBean<User> {
    //定义返回的 bean 类型
 @Override
 public User getObject() throws Exception {
  return new User("龙哥", );
 }

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

 @Override
 public boolean isSingleton() {
  return FactoryBean.super.isSingleton();
 }
}

书写配置文件

1	<bean id="mybean" class="com.pineapple_man.spring.bean.MyBean"></bean>

检查结果

public void beanTest() {
 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beanxml");
 User mybean= applicationContext.getBean("mybean", User.class);
 User mybean= applicationContext.getBean("mybean", User.class);
 System.out.println(mybeangetClass().hashCode());
 System.out.println(mybeangetClass().hashCode());
    //mybean与 mybean的hash值相同
}

¶Bean 作用域

默认情况下，Spring 中 bean 是单实例对象，通过修改配置文件，可以选择是单实例还是多实例

scope属性有两个值：singleton和prototype

1	<bean id="mybean" class="com.pineapple_man.spring.bean.MyBean" scope="prototype"></bean>

✨singleton和prototype的区别

singleton是单实例，prototype是多实例
scope 为singleton时，加载配置文件就会创建单实例对象
scope 为prototype时，调用getnBean()方法时创建多实例对象

¶bean 生命周期

✨ bean 的生命周期（七个阶段）：

通过构造器创建bean实例（无参数构造）
为bean的属性注入以及对其他bean引用(调用set()方法) 3. 将bean实例传递给bean后置处理器的方法postProcessBeforeInitialization 4. 调用bean的初始化方法（需要进行配置初始化的方法） 5. 将bean实例传递给bean后置处理器方法postProcessAfterInitialization
使用bean
在容器关闭时，调用bean的销毁方法（需要配置销毁方法）

¶Java Bean

public class LifeCycle {
   private String step;

   public LifeCycle() {
      System.out.println(" 来自于无参构造函数");
   }

   public void setStep(String step) {
      System.out.println(" 来自于set方法");
      this.step = step;
   }

   public void initMethod() {
      System.out.println(. 来自于initMethod");
   }

   public void destoryMethod() {
      System.out.println("5.来自destoryMethod");
   }
}

¶预处理和后处理类

public class PostProcess implements BeanPostProcessor {
 @Override
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  System.out.println("from postProcessBeforeInitialization");
  return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
 }

 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  System.out.println("from postProcessAfterInitialization");
  return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
 }
}

¶Spring 配置

<?xml version="0" encoding="UTF-?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www..org/0XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="lifecycle" class="com.pineapple_man.spring.bean.LifeCycle" init-method="initMethod"
          destroy-method="destoryMethod">
        <property name="step" value="start"></property>
    </bean>
    <bean id="postprocess" class="com.pineapple_man.spring.bean.PostProcess"></bean>
</beans>

🎶预处理和后处理将会作用在此文件的所有 bean 对象

¶xml 自动装配

✨自动状态就是——根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

//Java Bean
public class AutoInject {
 private User user;
 private User teacher;

 public AutoInject() {
 }

 @Override
 public String toString() {
  return "AutoInject{" +
    "user=" + user +
    ", teacher=" + teacher +
    '}';
 }

 public void setTeacher(User teacher) {
  this.teacher = teacher;
 }

 public void setUser(User user) {
  this.user = user;
 }
}

¶根据属性名称自动注入

🎶注入值 bean 的 id 值和类属性名称一样

<bean class="com.pineapple_man.spring.bean.AutoInject" id="autoInject" autowire="byName">
</bean>
<bean class="com.pineapple_man.spring.bean.User" id="user">
    <property name="name" value="tony"></property>
    <property name="age" value=""></property>
</bean>
<bean class="com.pineapple_man.spring.bean.User" id="teacher">
    <property name="age" value=""></property>
    <property name="name" value="Dany"></property>
</bean>

¶根据属性类型自动注入

🎶类型自动注入只能应用在类中只有这样一种类型的属性，否则可能找不到注入属性

<bean class="com.pineapple_man.spring.bean.AutoInject" id="autoInject" autowire="byType">
</bean>
<bean class="com.pineapple_man.spring.bean.User" id="user">
 <property name="name" value="tony"></property>
 <property name="age" value=""></property>
</bean>
<bean class="com.pineapple_man.spring.bean.User" id="teacher">
 <property name="age" value=""></property>
 <property name="name" value="Dany"></property>
</bean>

¶外部属性文件

将外部属性文件内的数据，导入到 Spring 配置文件中

¶直接配置数据库信息

<bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
 <property name="name" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:///t_user"></property>
    <property name="username" value="root"></property>
    <property name="password" value=45></property>
</bean>

public void druidTest) {
 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
 DruidDataSource dataSource = applicationContext.getBean("dataSource", DruidDataSource.class);
 System.out.println(dataSource.getPassword());
 System.out.println(dataSource.getUsername());
}

¶外部属性文件配置数据库连接池

¶增加 jdbc.properties 文件，保存数据库信息

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql:///
prop.userName=root
prop.password456

¶Spring 配置文件

<?xml version="0" encoding="UTF-?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www..org/0XMLSchema-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 class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="name" 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>
</beans>

¶注解方式管理 Bean

✨注解特点

注解是特殊标记，格式@注解名称(属性名称=属性值,...)
注解作用在类上面，方法上面，属性上面

:+使用注解方式管理 bean 的优点

简化 xml 配置
便于程序阅读

¶可用注解

🎶Sping 创建对象的四个注解：
@Component > @Service
. @Controller 4. @Repository

🎶上面四个注解功能是一样的，都是可以用来创建 bean 实例

¶.基于注解方式实现对象创建

主要共分为三个步骤

¶引入依赖

在项目中引入spring-aop-5.RELEASE.jar包

¶组件扫描配置

在 Spring 配置文件中进行组件扫描配置

<?xml version="0" encoding="UTF-?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www..org/0XMLSchema-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="com.pineapple_man.spring.aop"></context:component-scan>
</beans>

🎶组件扫描注意点

如果扫描多个包，多个包之间使用逗号隔开
如果一个目录中有多个类进行扫描，则配置自动扫描上层目录

¶Spring 托管创建实例

书写 Java Bean，在类上添加创建对象注解

@Component(value = "aopUserService")
public class AopUserService {
 public void method() {
  System.out.println("from AopUserService method");
 }
}

🎶@Component(value)中的value属性是可以省略不写的，默认值是：首字母小写的类名，如果书写了，value 等价与<bean>中的 id 属性

¶组件扫描详细配置

实现扫描过滤器配置，可以选择在包中，默认扫描那些类，不扫描那些类

<?xml version="0" encoding="UTF-?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www..org/0XMLSchema-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="com.pineapple_man.spring.aop"
                            use-default-filters="false">
  <!--默认仅扫描拥有 @Component 注解的类-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>
</beans>

✨扫描过滤器特点

use-default-filters="false"：表示不适用默认过滤器，用户自己配置过滤器
<context:include-filter type="" expression="">：设置那些内容进行扫描
<context:exclude-filter type="" expression="">：设置那些内容不进行扫描

¶注解方式实现属性注入

注解	含义
`@Autowired`	根据属性类型进行自动装配
`@Qualifier`	根据名称进行注入，需要和`@Autowired`一起使用
`@Resource`	可以根据类型注入也可以根据名称注入
`@Value`	注入普通类型属性

@Repository(value = "aopDao")
public class AopDao {
 public void method() {
  System.out.println("From aopDao method");
 }
}

¶@Autowired

@Component(value = "aopUserService")
public class AopUserService {
 @Autowired
 private AopDao aopDao;

 public void method() {
  System.out.println("from AopUserService method");
  aopDao.method();
 }
}

🎶@Autowired注解不需要属性具有setXxx()方法

¶@Qualifier

@Component(value = "aopUserService")
public class AopUserService {
 @Autowired
 @Qualifier(value = "aopDao")
 private AopDao aopDao;

 public void method() {
  System.out.println("from AopUserService method");
  aopDao.method();
 }
}

🎶根据名称( id )注入，需要和@Autowired一起使用

¶@Resource

@Component(value = "aopUserService")
public class AopUserService {
 @Resource(name = "aopDao")
 private AopDao aopDao;

 public void method() {
  System.out.println("from AopUserService method");
  aopDao.method();
 }
}

🎶@Resource可以根据类型注入，也可以根据名称注入

@Resource：根据类型进行注入
@Resource(name = "aopDao")：根据名称进行注入
此注解所在的包是javax.annotation.Resource

¶@Value

@Component(value = "aopUserService")
public class AopUserService {

 @Resource(name = "aopDao")
 private AopDao aopDao;

 @Value("pineapple-man")
 private String name;

 public void method() {
  System.out.println("from AopUserService method");
  aopDao.method();
  System.out.println(name);
 }
}

🎶对普通类型属性进行注入

¶完全注解开发

不再需要冗长的配置文件，使用一个配置类代替所有的配置文件

¶注解配置类

@Configuration
@ComponentScan(basePackages = {"com.pineapple_man.spring.aop"})
public class SpringConfig {
}

✨注解类特点

@Configuration配置类注解，声明当前类是配置类
@ComponentScan(basePackages = {"com"})自动扫描包注解

¶测试方法

public void annotationConfigTest() {
 ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
 AopUserService aopUserService = applicationContext.getBean("aopUserService", AopUserService.class);
  aopUserService.method();
}