Spring框架笔记

DI 依赖注入（Dependency Injection）

完全配置文件模板

<?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="sfactory" class="top.tdte.servies.BeanFactory"/>
    <!--    <bean id="getService" factory-bean="sfactory" factory-method="getSerImpl"/>-->
    <!-- 方式三 使用工厂中的静态方法-->
    <bean id="getService2" class="top.tdte.servies.BeanFactory" factory-method="getSerImpl">
    </bean>
</beans>

注解配置文件模板

<?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:annotation-config/>
    <!-- 扫描top.tdte包下的所有注解 -->
    <context:component-scan base-package="top.tdte"/>
</beans>

---

1. IOC的作用： 降低程序间的耦合（依赖关系）
2. 依赖关系的管理：以后都交给spring来维护 在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明
3. 依赖关系的维护： 就称之为依赖注入。
4. 能注入的数据：有三类
   基本类型和String
   其他bean类型（在配置文件中或者注解配置过的bean）
   复杂类型/集合类型
5. 注入的方式：有三种
   第一种：使用构造函数提供
   第二种：使用set方法提供
   第三种：使用注解提供（明天的内容）

---

配置文件

构造函数注入：

• 使用的标签:constructor-arg
  • 标签出现的位置：bean标签的内部
  • 标签中的属性
    type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
    index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
    name：用于指定给构造函数中指定名称的参数赋值
    value：用于提供基本类型和String类型的数据
    ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
  • 优势：在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
  • 弊端：改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

 <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
     <constructor-arg name="name" value="泰斯特"></constructor-arg>
     <constructor-arg name="age" value="18"></constructor-arg>
     <constructor-arg name="birthday" ref="now"></constructor-arg>
 </bean>

 <!-- 配置一个日期对象 -->
 <bean id="now" class="java.util.Date"></bean>

---

set方法注入(更常用的方式)

1. 涉及的标签：property
2. 出现的位置：bean标签的内部
3. 标签的属性
   name：用于指定注入时所调用的set方法名称
   value：用于提供基本类型和String类型的数据
   ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
4. 优势：创建对象时没有明确的限制，可以直接使用默认构造函数
5. 弊端：如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

<bean id="accountService2" class="com.itheima.service.impl.AccountServiceImpl2">
    <property name="name" value="TEST" ></property>
    <property name="age" value="21"></property>
    <property name="birthday" ref="now"></property>
</bean>

---

配置文件中Bean的自动装配

byName属性:会自动在容器上下文中查找和自己对象set方法后面的值（setDog 中的dog）对应的bean id

<!-- 测试用例 -->
<bean id="dog" class="top.tdte.pojo.Dog"/>
<!--  pepole中有dog为的set方法  -->
<bean id="people" class="com.kuang.pojo.People" autowire="byName" />

byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean！必须保证类型全局唯一。

<!--  如下面有两个类型一样的bean对象会报错  -->
<bean id="dog" class="top.tdte.pojo.Dog"/>
<!--<bean id="dog1" class="top.tdte.pojo.Dog"/>-->
<bean id="people" class="com.kuang.pojo.People" autowire="byType" />

• byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
• byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！

---

复杂类型注入

1. 复杂类型的注入/集合类型的注入
2. 用于给List结构集合注入的标签：list array set
3. 用于个Map结构集合注入的标签: map props
4. 结构相同，标签可以互换

<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
     <property name="myStrs">
         <set>
             <value>AAA</value>
             <value>BBB</value>
             <value>CCC</value>
         </set>
     </property>

     <property name="myList">
         <array>
             <value>AAA</value>
             <value>BBB</value>
             <value>CCC</value>
         </array>
     </property>

     <property name="mySet">
         <list>
             <value>AAA</value>
             <value>BBB</value>
             <value>CCC</value>
         </list>
     </property>

     <property name="myMap">
         <props>
             <prop key="testC">ccc</prop>
             <prop key="testD">ddd</prop>
         </props>
     </property>

     <property name="myProps">
         <map>
             <entry key="testA" value="aaa"></entry>
             <entry key="testB">
                 <value>BBB</value>
             </entry>
         </map>
     </property>
 </bean>

---

把对象的创建交给spring来管理

1. 使用默认构造函数创建。
   在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

 <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" />

2. 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）

    <bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

3. 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)

<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>

---

• bean的作用范围调整
  • bean标签的scope属性：
    • 作用：用于指定bean的作用范围
    • 取值： 常用的就是单例的和多例的
      singleton：单例的（默认值）
      prototype：多例的
      request：作用于web应用的请求范围
      session：作用于web应用的会话范围
      global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="prototype"></bean>

---

• bean对象的生命周期
  • 单例对象
    出生：当容器创建时对象出生
    活着：只要容器还在，对象一直活着
    死亡：容器销毁，对象消亡
    总结：单例对象的生命周期和容器相同
  • 多例对象
    出生：当我们使用对象时spring框架为我们创建
    活着：对象只要是在使用过程中就一直活着。
    死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"
scope="prototype" init-method="init" destroy-method="destroy"></bean>

---

注解注入

1. 使用注解前提是你能修改源文件，对于第三方jar包还是需要配置文件的方式进行注入

<!-- 告知Spring扫描top.tdte包下的所有注解 -->
<context:component-scan base-package="top.tdte"/>

<!--配置QueryRunner-->
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
    <!--注入数据源-->
    <constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>

<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!--连接数据库的必备信息-->
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy"></property>
    <property name="user" value="root"></property>
    <property name="password" value="1234"></property>
</bean>

---

用于创建对象的注解

• 他们的作用就和在XML配置文件中编写一个标签实现的功能是一样的

1. Component:
   作用：用于把当前类对象存入spring容器中
   属性： value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
2. 以下三个注解他们的作用和属性与Component是一模一样。他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰
   Controller：一般用在表现层
   Service：一般用在业务层
   Repository：一般用在持久层

---

用于注入数据的注解

• 他们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一样的

1. Autowired:
   作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功。 如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。
   如果Ioc容器中有多个类型匹配时：
   属性：required：如果=false，则可以为null。
   出现位置： 可以是变量上，也可以是方法上
   细节： 在使用注解注入时，set方法就不是必须的了。

2. Qualifier:
   作用：与Autowired配合使用，在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用。但是在给方法参数注入时可以（稍后我们讲）
   属性：value：用于指定注入bean的id。

3. Resource（不是spring的注解，是本地java的注解）
   作用：可以自动识别bean的id或者根据类型装配
   属性：name：用于指定bean的id。
   以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。
   另外，集合类型的注入只能通过XML来实现。

4. Value
   作用：用于注入基本类型和String类型的数据
   属性：value：用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式） SpEL的写法：${表达式} 用于改变作用范围的 他们的作用就和在bean标签中使用scope属性实现的功能是一样的

5. Scope
   作用：用于指定bean的作用范围
   属性：value：指定范围的取值。常用取值：singleton prototype 和生命周期相关了解 他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的

6. PreDestroy
   作用：用于指定销毁方法

7. PostConstruct
   作用：用于指定初始化方法

@Service("accountService")
@Scope("prototype")
public class AccountServiceImpl implements IAccountService {

//    @Autowired
//    @Qualifier("accountDao1")
    @Resource(name = "accountDao2")
    private IAccountDao accountDao = null;
    @Value("Ken")
	private String name;
    @PostConstruct
    public void  init(){
        System.out.println("初始化方法执行了");
    }

    @PreDestroy
    public void  destroy(){
        System.out.println("销毁方法执行了");
    }

    public void  saveAccount(){
        accountDao.saveAccount();
    }
}

---

配置类注解

• 配置类可以有多个 可以通过Configuration注解加包扫描或者AnnotationConfigApplicationContext可变参数列表进行整合使用。

1. Configuration（类上）
   作用：标识当前类是一个配置类，可以被包扫描配置扫描到
   细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以省略

2. ComponentScan（类上）
   作用：用于通过注解指定spring在创建容器时要扫描的包
   属性： value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包。
   使用此注解就等同于在xml中配置了:
   <context:component-scan base-package="com.itheima" />

   扫描二维码关注公众号，回复： 8893171 查看本文章

3. Bean注解（方法上）
   作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
   属性：name:用于指定bean的id。当不写时，默认值是当前方法的名称
   细节：当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象。
   查找的方式和Autowired注解的作用是一样的

4. Import注解 （类上）
   作用：用于导入其他的配置类
   属性：value：用于指定其他配置类的字节码。
   当我们使用Import的注解之后，有Import注解的类就父配置类，而导入的都是子配置类

5. PropertySource（类上）
   作用：用于指定properties文件的位置 ，并联合value注解进行配置文件注入
   属性：value：指定文件的名称和路径
   关键字：classpath，表示类路径下有包就在写包路径，无包可以省略@PropertySource("classpath:top/tdte/jdbcConfig.properties")

@Configuration
@ComponentScan("com.itheima")  //扫描包路径
@Import(JdbcConfig.class)//导入其他配置类
@PropertySource("classpath:jdbcConfig.properties")//配置文件路径 用于加载${key名称}EL表达式
public class SpringConfiguration {
    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;
}

配置文件内容

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy
jdbc.username=root
jdbc.password=1234

---

使用Junit单元测试（Spring整合junit的配置）

1. 导入spring整合junit的jar

<dependency>
 	 <groupId>org.springframework</groupId>
 	 <artifactId>spring-test</artifactId>
  	 <version>5.2.3.RELEASE</version>
</dependency>

2. junit包提供的替换注解，下面这个例子是把原运行器替换为spring的测试单元
   @RunWith(SpringJUnit4ClassRunner.class)
3. 告知spring的运行器，spring和ioc创建是基于xml还是注解的，并且说明位置
   @ContextConfiguration(locations = "classpath:beans.xml")
   locations：指定xml文件的位置，加上classpath关键字，表示在类路径下
   classes：指定注解类所在地位置

当我们使用spring 5.x版本的时候，要求junit的jar必须是4.12及以上
示例：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {

    @Autowired
    private IAccountService as = null;

    @Test
    public void testFindAll() {
        //3.执行方法
        List<Account> accounts = as.findAllAccount();
        for(Account account : accounts){
            System.out.println(account);
        }
    }
}