Spring知识点记录

迈不过友情╰ 2024-03-29 15:07 85阅读 0赞

#### Spring知识点 ####

*  1. Spring简介（此章略过）
 *   *  1.1 Spring概述
     *  1.2 Spring家族
     *  1.3 Spring Framework
 *  2. IOC
 *   *  2.1 IOC容器
     *  2.2 基于XML管理bean
     *   *  2.2.1 入门案例（ioc容器的整体思路）
         *  2.2.2 获取bean的三种方式
         *  2.2.3 依赖注入
         *   *  2.2.3.1 setter注入
             *  2.2.3.2 构造器注入
         *  2.2.4 特殊值处理
         *  2.2.5 为类类型属性赋值
         *  2.2.6 为数组类型属性赋值
         *  2.2.7 为集合类型属性赋值
         *   *  2.2.7.1 为List集合赋值
             *  2.2.7.2 为Map集合赋值
         *  2.2.8 p命名空间
         *  2.2.9 引入外部属性文件
         *  2.2.10 bean的作用域
         *  2.2.11 bean的生命周期
         *  2.2.12 FactoryBean
         *  2.2.13 基于xml的自动装配
     *  2.3 基于注解管理bean
     *   *  2.3.1 标记与扫描
         *   *  2.3.1.1 标记
             *  2.3.1.2 扫描
             *  2.3.1.3 bean的id
         *  2.3.2 基于注解的自动装配
 *  3. AOP
 *   *  3.1 场景模拟
     *  3.2 代理模式
     *  3.3 AOP概念及相关术语
     *  3.4 基于注解的AOP
     *  3.5 基于XML的AOP（了解）
 *  4. 声明式事务
 *   *  4.1 JdbcTemplate
     *  4.2 声明式事务概念
     *  4.3 基于注解的声明式事务
     *  4.4 基于XML的声明式事务

--------------------

## 1. Spring简介（此章略过） ##

### 1.1 Spring概述 ###

### 1.2 Spring家族 ###

### 1.3 Spring Framework ###

--------------------

## 2. IOC ##

### 2.1 IOC容器 ###

> IOC：Inversion of Control，翻译过来是反转控制。  
> DI：Dependency Injection，翻译过来是依赖注入。

### 2.2 基于XML管理bean ###

#### 2.2.1 入门案例（ioc容器的整体思路） ####

**类和方法：**

> 文件位置：src/main/java/com/atguigu/spring/pojo/HelloWorld.java

package com.atguigu.spring.pojo;
    
    public class HelloWorld {
        
        public void sayHello(){
        
            System.out.println("hello,spring");
        }
    }

**Spring配置文件**

创建方式：  
![Spring配置文件创建方式][Spring]

> 文件位置：src/main/resources/applicationContext.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="helloworld" class="com.atguigu.spring.pojo.HelloWorld"></bean>
    </beans>

**测试类**

> 文件位置：src/test/java/com/atguigu/spring/test/HelloWorldTest.java

package com.atguigu.spring.test;
    
    import com.atguigu.spring.pojo.HelloWorld;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class HelloWorldTest {
        
        @Test
        public void test(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //获取IOC容器中的Bean对象
            HelloWorld helloworld = (HelloWorld) ioc.getBean("helloworld");
            helloworld.sayHello();
        }
    }

#### 2.2.2 获取bean的三种方式 ####

> 获取bean的方式：  
> 1、根据id获取  
> 2、根据类型获取（最常用）  
> 3、根据id和类获取

/**
         * 获取bean的三种方式：
         * 1、根据id获取；
         * 2、根据类型获取；（使用最多的方式）
         *  注意：根据类型获取bean时，要求IOC容器中有且只有一个类型匹配的bean。
         *  若没有任何一个类型匹配的bean，此时抛出异常：NoSuchBeanDefinitionException
         *  若有多个类型匹配的bean，此时抛出异常：NoUniqueBeanDefinitionException
         * 3、根据id和类型获取；
         */
        @Test
        public void testIOC(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //获取bean的第一种方法：根据id获取bean
            //Student studentOne = (Student) ioc.getBean("studentOne");
    
            //获取bean的第二种方法：根据类型获取bean
            Student student = ioc.getBean(Student.class);
    
            //获取bean的第三种方法：根据id和类型来获取bean
            //Student studentOne = ioc.getBean("studentOne", Student.class);
            System.out.println(studentOne);
        }

#### 2.2.3 依赖注入 ####

##### 2.2.3.1 setter注入 #####

**学生类**

package com.atguigu.spring.pojo;
    
    import java.util.Arrays;
    import java.util.Map;
    
    public class Student {
        
        private Integer sid;
        private String sname;
        private Integer age;
        private String gender;
        private Double score;
        private Clazz clazz;
        private String[] hobby;
        private Map<String,Teacher> teacherMap;
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "sid=" + sid +
                    ", sname='" + sname + '\'' +
                    ", age=" + age +
                    ", gender='" + gender + '\'' +
                    ", score=" + score +
                    ", clazz=" + clazz +
                    ", hobby=" + Arrays.toString(hobby) +
                    ", teacherMap=" + teacherMap +
                    '}';
        }
    
        public Map<String, Teacher> getTeacherMap() {
        
            return teacherMap;
        }
    
        public void setTeacherMap(Map<String, Teacher> teacherMap) {
        
            this.teacherMap = teacherMap;
        }
    
        public String[] getHobby() {
        
            return hobby;
        }
    
        public void setHobby(String[] hobby) {
        
            this.hobby = hobby;
        }
    
        public Clazz getClazz() {
        
            return clazz;
        }
    
        public void setClazz(Clazz clazz) {
        
            this.clazz = clazz;
        }
    
        public Double getScore() {
        
            return score;
        }
    
        public void setScore(Double score) {
        
            this.score = score;
        }
    
        public Integer getSid() {
        
            return sid;
        }
    
        public void setSid(Integer sid) {
        
            this.sid = sid;
        }
    
        public String getSname() {
        
            return sname;
        }
    
        public void setSname(String sname) {
        
            this.sname = sname;
        }
    
        public Integer getAge() {
        
            return age;
        }
    
        public void setAge(Integer age) {
        
            this.age = age;
        }
    
        public String getGender() {
        
            return gender;
        }
    
        public void setGender(String gender) {
        
            this.gender = gender;
        }
    
        public Student() {
        
        }
    
        public Student(Integer sid, String sname,String gender , Integer age) {
        
            this.sid = sid;
            this.sname = sname;
            this.gender = gender;
            this.age = age;
        }
        public Student(Integer sid, String sname, String gender, Double score) {
        
            this.sid = sid;
            this.sname = sname;
            this.gender = gender;
            this.score = score;
        }
    }

**spring配置文件**

<bean id="studentTwo" class="com.atguigu.spring.pojo.Student">
            
            <property name="sid" value="1001"></property>
            <property name="sname" value="张三"></property>
            <property name="gender" value="男"></property>
            <property name="age" value="23"></property>
        </bean>

**测试类**

public void testDI(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //setter注入
            Student studentTwo = ioc.getBean("studentTwo", Student.class);
            System.out.println(studentTwo);
           }

##### 2.2.3.2 构造器注入 #####

**学生类同上（需要设置有参构造）**  
**Spring配置文件**

<bean id="studentThree" class="com.atguigu.spring.pojo.Student">
            <constructor-arg name="sid" value="1002"></constructor-arg>
            <constructor-arg name="sname" value="李四"></constructor-arg>
            <constructor-arg name="gender" value="女"></constructor-arg>
            <constructor-arg name="age" value="24"></constructor-arg>
        </bean>

**测试类**

public void testDI(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //构造器注入
            Student studentThree = ioc.getBean("studentThree", Student.class);
            System.out.println(studentThree);
           }

#### 2.2.4 特殊值处理 ####

> **特殊值处理：**  
> 1、赋值null  
> 2、使用XML特殊符号赋值  
> 3、使用CDATA节赋值

<bean id="studentFour" class="com.atguigu.spring.pojo.Student">
            
            <property name="sname"><null/></property>
            
            <property name="sname" value="<王五>"></property>
            
            <property name="sname"><value><![CDATA[<王五>]]></value></property>
        </bean>

#### 2.2.5 为类类型属性赋值 ####

**student类**

**clazz类**

package com.atguigu.spring.pojo;
    
    import java.util.List;
    
    public class Clazz {
        
        private Integer cid;
        private String cname;
    
        private List<Student> students;
    
        @Override
        public String toString() {
        
            return "Clazz{" +
                    "cid=" + cid +
                    ", cname='" + cname + '\'' +
                    ", students=" + students +
                    '}';
        }
    
        public List<Student> getStudents() {
        
            return students;
        }
    
        public void setStudents(List<Student> students) {
        
            this.students = students;
        }
    
        public Clazz() {
        
        }
    
        public Clazz(Integer cid, String cname) {
        
            this.cid = cid;
            this.cname = cname;
        }
    
        public Integer getCid() {
        
            return cid;
        }
    
        public void setCid(Integer cid) {
        
            this.cid = cid;
        }
    
        public String getCname() {
        
            return cname;
        }
    
        public void setCname(String cname) {
        
            this.cname = cname;
        }
    
    }

**类类型赋值的三种方式**

> **类类型赋值的三种方式：**  
> 1、引用外部已经声明的bean的方式  
> 2、级联方式  
> 3、内部bean方式

<bean id="studentFive" class="com.atguigu.spring.pojo.Student">
            <property name="sid" value="1003"></property>
            <property name="sname" value="赵六"></property>
            <property name="age" value="26"></property>
            <property name="gender" value="男"></property>
            
            <property name="clazz" ref="clazzOne"></property>
        </bean>
        <bean id="clazzOne" class="com.atguigu.spring.pojo.Clazz">
            <property name="cid" value="1111"></property>
            <property name="cname" value="最强王者班"></property>
        </bean>
        
        <bean id="studentFiveA" class="com.atguigu.spring.pojo.Student">
            <property name="sid" value="1003"></property>
            <property name="sname" value="赵六"></property>
            <property name="age" value="26"></property>
            <property name="gender" value="男"></property>
            
            <property name="clazz" ref="clazzOne"></property>
            <property name="clazz.cid" value="1112"></property>
            <property name="clazz.cname" value="远大前程班"></property>
        </bean>
        
        <bean id="studentFiveB" class="com.atguigu.spring.pojo.Student">
            <property name="sid" value="1003"></property>
            <property name="sname" value="赵六"></property>
            <property name="age" value="26"></property>
            <property name="gender" value="男"></property>
            
            <property name="clazz">
                <bean id="clazzInner" class="com.atguigu.spring.pojo.Clazz">
                    <property name="cid" value="1113"></property>
                    <property name="cname" value="超级牛逼班"></property>
                </bean>
            </property>
        </bean>

**测试类**

@Test
        public void testDI(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //类类型赋值
            //1、外部bean方式
            Student studentFive = ioc.getBean("studentFive", Student.class);
            System.out.println(studentFive);
            //外部bean是可以通过IOC容器获取的
            Clazz clazzOne = ioc.getBean("clazzOne", Clazz.class);
            System.out.println(clazzOne);
    
            //级联方式
            Student studentFiveA = ioc.getBean("studentFiveA", Student.class);
            System.out.println(studentFiveA);
            //内部bean方式
            Student studentFiveB = ioc.getBean("studentFiveB", Student.class);
            System.out.println(studentFiveB);
            //注意：内部bean是无法通过IOC容器来获取的
            Clazz clazzInner = ioc.getBean("clazzInner", Clazz.class);
            System.out.println(clazzInner); //结果异常：NoSuchBeanDefinitionException
          }

#### 2.2.6 为数组类型属性赋值 ####

**student类**

**bean配置**

<bean id="studentFiveC" class="com.atguigu.spring.pojo.Student">
            <property name="sid" value="1003"></property>
            <property name="sname" value="赵六"></property>
            <property name="age" value="26"></property>
            <property name="gender" value="男"></property>
            <property name="clazz">
                <bean id="clazzInner" class="com.atguigu.spring.pojo.Clazz">
                    <property name="cid" value="1113"></property>
                    <property name="cname" value="超级牛逼班"></property>
                </bean>
            </property>
            <property name="hobby">
                <array>
                    
                    <value>抽烟</value>
                    <value>喝酒</value>
                    <value>烫头</value>
                </array>
            </property>
        </bean>

**测试类**

@Test
        public void testDI(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //数组类型的属性值
            Student studentFiveC = ioc.getBean("studentFiveC", Student.class);
            System.out.println(studentFiveC);
          }

#### 2.2.7 为集合类型属性赋值 ####

##### 2.2.7.1 为List集合赋值 #####

**clazz类**

**bean配置**

<bean id="clazzTwo" class="com.atguigu.spring.pojo.Clazz">
            <property name="cid" value="1111"></property>
            <property name="cname" value="最强王者班"></property>
            
            <property name="students">
                <list>
                    
                    <ref bean="studentOne"></ref>
                    <ref bean="studentTwo"></ref>
                    <ref bean="studentThree"></ref>
                </list>
            </property>
            
            <property name="students" ref="studentList"></property>
        </bean>
        
        <util:list id="studentList">
            <ref bean="studentOne"></ref>
            <ref bean="studentTwo"></ref>
            <ref bean="studentThree"></ref>
        </util:list>

**测试类**

@Test
        public void testDI(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //List集合类型的属性值
            Clazz clazzTwo = ioc.getBean("clazzTwo", Clazz.class);
            System.out.println(clazzTwo);
        }

##### 2.2.7.2 为Map集合赋值 #####

**Teacher类**

package com.atguigu.spring.pojo;
    
    public class Teacher {
        
        private Integer tid;
        private String tname;
    
        @Override
        public String toString() {
        
            return "teacher{" +
                    "tid=" + tid +
                    ", tname='" + tname + '\'' +
                    '}';
        }
    
        public Teacher() {
        
        }
    
        public Teacher(Integer tid, String tname) {
        
            this.tid = tid;
            this.tname = tname;
        }
    
        public Integer getTid() {
        
            return tid;
        }
    
        public void setTid(Integer tid) {
        
            this.tid = tid;
        }
    
        public String getTname() {
        
            return tname;
        }
    
        public void setTname(String tname) {
        
            this.tname = tname;
        }
    }

**Student类**

**Bean配置**

<bean id="studentFiveD" class="com.atguigu.spring.pojo.Student">
            <property name="sid" value="1003"></property>
            <property name="sname" value="赵六"></property>
            <property name="age" value="26"></property>
            <property name="gender" value="男"></property>
            <property name="clazz">
                <bean id="clazzInner" class="com.atguigu.spring.pojo.Clazz">
                    <property name="cid" value="1113"></property>
                    <property name="cname" value="超级牛逼班"></property>
                </bean>
            </property>
            <property name="hobby">
                <array>
                    
                    <value>抽烟</value>
                    <value>喝酒</value>
                    <value>烫头</value>
                </array>
            </property>
            
            <property name="teacherMap">
                <map>
                    <entry key="10086" value-ref="teacherOne"></entry>
                    <entry key="10087" value-ref="teacherTwo"></entry>
                </map>
            </property>
            
            <property name="teacherMap" ref="teacherMap"></property>
        </bean>
        <bean id="teacherOne" class="com.atguigu.spring.pojo.Teacher">
            <property name="tid" value="10086"></property>
            <property name="tname" value="大宝"></property>
        </bean>
        <bean id="teacherTwo" class="com.atguigu.spring.pojo.Teacher">
            <property name="tid" value="10087"></property>
            <property name="tname" value="小宝"></property>
        </bean>
        <util:map id="teacherMap">
            <entry key="10086" value-ref="teacherOne"></entry>
            <entry key="10087" value-ref="teacherTwo"></entry>
        </util:map>

**测试类**

@Test
        public void testDI(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //Map集合类型的属性值
            Student studentFiveD = ioc.getBean("studentFiveD", Student.class);
            System.out.println(studentFiveD);
        }

#### 2.2.8 p命名空间 ####

**bean配置**

<bean id="studentSix" class="com.atguigu.spring.pojo.Student"
            p:sid="1005" p:sname="小明" p:teacherMap-ref="teacherMap"></bean>

**测试类**

@Test
        public void testDI(){
        
            //获取IOC容器
            ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
            //p命名空间
            Student studentSix = ioc.getBean("studentSix", Student.class);
            System.out.println(studentSix);
        }

#### 2.2.9 引入外部属性文件 ####

**依赖**

<dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.16</version>
            </dependency>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.0.31</version>
            </dependency>

**外部属性文件**  
![在这里插入图片描述][824ea83cddfe4a129811cbd19b97ec39.png]

jdbc.driver=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://127.0.0.1:3306/ssm?serverTimezone=UTC
    jdbc.username=root
    jdbc.password=root

**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"
           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 https://www.springframework.org/schema/context/spring-context.xsd">
        
        
        
        
        
        
        
    
        
        <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
        
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${jdbc.driver}"></property>
            <property name="url" value="${jdbc.url}"></property>
            <property name="username" value="${jdbc.username}"></property>
            <property name="password" value="${jdbc.password}"></property>
        </bean>
    </beans>

**测试类**

package com.atguigu.spring.test;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import java.sql.SQLException;
    
    public class DataSourceTest {
        
        @Test
        public void testDataSource() throws SQLException {
        
        	//获取IOC容器
            ApplicationContext  ioc = new ClassPathXmlApplicationContext("spring-datasource.xml");
            DruidDataSource dataSource = ioc.getBean(DruidDataSource.class);
            System.out.println(dataSource.getConnection());
        }
    }

#### 2.2.10 bean的作用域 ####

**user类**

package com.atguigu.spring.pojo;
    
    public class User {
        
        private Integer id;
        private String username;
        private String password;
        private Integer age;
        public User() {
        
            System.out.println("生命周期1：实例化");
        }
        public User(Integer id, String username, String password, Integer age) {
        
            this.id = id;
            this.username = username;
            this.password = password;
            this.age = age;
        }
        public Integer getId() {
        
            return id;
        }
        public void setId(Integer id) {
        
            System.out.println("生命周期2：依赖注入");
            this.id = id;
        }
        public String getUsername() {
        
            return username;
        }
        public void setUsername(String username) {
        
            this.username = username;
        }
        public String getPassword() {
        
            return password;
        }
        public void setPassword(String password) {
        
            this.password = password;
        }
        public Integer getAge() {
        
            return age;
        }
        public void setAge(Integer age) {
        
            this.age = age;
        }
        @Override
        public String toString() {
        
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    ", age=" + age +
                    '}';
        }
        public void initMethod(){
        
            System.out.println("生命周期3：初始化");
        }
        public void destoryMethod(){
        
            System.out.println("生命周期4：销毁");
        }
    }

**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 id="student" class="com.atguigu.spring.pojo.Student" scope="singleton">
            <property name="sid" value="1001"></property>
            <property name="sname" value="张三"></property>
            <property name="score" value="100"></property>
        </bean>
    </beans>

**测试类**

@Test
        public void testScope(){
        
            ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-scope.xml");
            Student student = ioc.getBean(Student.class);
            Student student1 = ioc.getBean(Student.class);
            System.out.println(student.equals(student1));
    
        }

#### 2.2.11 bean的生命周期 ####

> **具体的生命周期**  
> bean对象创建（调用无参构造器）  
> 给bean对象设置属性  
> bean对象初始化之前操作（由bean的后置处理器负责）  
> bean对象初始化（需在配置bean时指定初始化方法）  
> bean对象初始化之后操作（由bean的后置处理器负责）  
> bean对象就绪可以使用  
> bean对象销毁（需在配置bean时指定销毁方法）  
> IOC容器关闭  
> **user类**

**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 id="user" class="com.atguigu.spring.pojo.User" init-method="initMethod" destroy-method="destoryMethod">
            <property name="id" value="1"></property>
            <property name="username" value="admin"></property>
            <property name="password" value="123456"></property>
            <property name="age" value="23"></property>
        </bean>
        <bean id="myBeanPostProcessor" class="com.atguigu.spring.process.MyBeanPostProcessor">
    
        </bean>
    </beans>

**bean的后置处理器**

package com.atguigu.spring.process;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    
    public class MyBeanPostProcessor implements BeanPostProcessor {
        
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
            //此方法在bean的生命周期初始化之前执行
            System.out.println("MyBeanPostProcessor-->后置处理器postProcessBeforeInitialization");
            return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        
            //此方法在bean的生命周期初始化之后执行
            System.out.println("MyBeanPostProcessor-->后置处理器postProcessAfterInitialization");
            return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
        }
    }

**测试类**

/**
         * 生命周期：
         * 1、实例化
         * 2、依赖注入
         * 3、后置处理器的postProcessBeforeInitialization
         * 4、初始化：需要通过bean的init-method属性来指定初始化的方法。
         * 5、后置处理器的postProcessAfterInitialization
         * 6、销毁（IOC容器关闭时候销毁）：需要通过bean的destory-method属性来指定销毁的方法。
         *
         * 注意：
         *  若bean的作用域为单例时，生命周期的（实例化、依赖注入、初始化）会在获取IOC容器的时候就执行了；
         *  若bean的作用域为多例时，生命周期的（实例化、依赖注入、初始化）就会在获取bean的时候执行；
         */
        @Test
        public void test(){
        
            //bean的生命周期
            //ConfigurableApplicationContext是ApplicationContext的子接口，其中扩展了刷新和关闭容器的方法；
            ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
            User user = ioc.getBean(User.class);
            System.out.println(user);
            ioc.close();
        }

#### 2.2.12 FactoryBean ####

**UserFactoryBean类**

package com.atguigu.spring.factory;
    
    import com.atguigu.spring.pojo.User;
    import org.springframework.beans.factory.FactoryBean;
    
    /**
     * FactoryBean是一个接口，需要创建一个类实现接口。
     * 其中，有三个方法：
     *  1、getObject():通过一个对象交给IOC容器管理；
     *  2、getObjectType():设置所提供对象的类型；
     *  3、isSingleton():所提供的对象是否单例；
     * 当把FactoryBean的实现类配置为bean时，会将当前类中getObject()所返回的对象交给IOC容器管理。
     */
    public class UserFactoryBean implements FactoryBean<User> {
        
        @Override
        public User getObject() throws Exception {
        
            return new User();
        }
    
        @Override
        public Class<?> getObjectType() {
        
            return User.class;
        }
    }

**bean配置**

**测试类**

package com.atguigu.spring.test;
    
    import com.atguigu.spring.pojo.User;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class FactoryBeanTest {
        
        @Test
        public void testFactoryBean(){
        
            ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-factory.xml");
            User user = ioc.getBean(User.class);
            System.out.println(user);
        }
    }

#### 2.2.13 基于xml的自动装配 ####

**UserController 类**

package com.atguigu.spring.controller;
    
    import com.atguigu.spring.service.UserService;
    import com.atguigu.spring.service.impl.UserServiceImpl;
    
    public class UserController {
        
        private UserService userService;
    
        public UserService getUserService() {
        
            return userService;
        }
    
        public void setUserService(UserService userService) {
        
            this.userService = userService;
        }
        public void saveUser(){
        
            userService.saveUser();
        }
    }

**UserService 接口**

package com.atguigu.spring.service;
    
    public interface UserService {
        
        /**
         * 保存用户信息
         */
        void saveUser();
    }

**UserServiceImpl 实现类**

package com.atguigu.spring.service.impl;
    
    import com.atguigu.spring.dao.UserDao;
    import com.atguigu.spring.service.UserService;
    
    public class UserServiceImpl implements UserService {
        
        private UserDao userDao;
    
        public UserDao getUserDao() {
        
            return userDao;
        }
    
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }
    
        @Override
        public void saveUser() {
        
            userDao.saveUser();
        }
    }

**UserDao 接口**

package com.atguigu.spring.dao;
    
    public interface UserDao {
        
        /**
         * 保存用户信息
         */
        void saveUser();
    }

**UserDaoImpl 实现类**

package com.atguigu.spring.dao.impl;
    
    import com.atguigu.spring.dao.UserDao;
    
    public class UserDaoImpl implements UserDao {
        
        @Override
        public void saveUser() {
        
            System.out.println("保存成功");
        }
    }

**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 id="userController" class="com.atguigu.spring.controller.UserController" autowire="constructor">
            
        </bean>
    
        <bean id="userService" class="com.atguigu.spring.service.impl.UserServiceImpl" autowire="constructor">
            
        </bean>
    
        <bean id="userDao" class="com.atguigu.spring.dao.impl.UserDaoImpl">
    
        </bean>
    </beans>

**测试类**

package com.atguigu.spring.test;
    
    import com.atguigu.spring.controller.UserController;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class AutowireByXMLTest {
        
        /**
         * 自动装配：
         * 根据指定的策略，在IOC容器中匹配某个bean，自动为bean中的类类型的属性或接口类型的属性赋值。
         * 可以通过bean标签中的autowire属性来设置自动装配的策略。
         * 自动装配的策略：
         * 1、no,default:表示不装配，即bean中的属性不会自动匹配某个bean为属性赋值，此时属性使用默认值。
         * 2、byType:根据当前要赋值的属性的类型，在IOC容器中匹配某个bean，为属性赋值。
         *  注意：
         *      （1）若通过类型没有找到任何一个类型匹配的bean，此时属性就不装配，属性使用的默认值。默认值为null。
         *      （2）若通过类型找到了多个类型匹配的bean，则此时会抛出异常NoUniqueBeanDefinitionException。
         *      总结：当使用byType实现自动装配时，IOC容器有且只有一个类型匹配的bean能够为属性赋值。
         * 3、byName:将要赋值的属性的属性名作为bean的id在IOC容器中匹配到某个bean，为属性赋值。
         *  总结：当使用byType类型匹配的bean有多个时，此时可以使用byName来实现自动装配。
         */
        @Test
        public void testAutowire(){
        
            ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-autowire-xml.xml");
            UserController userController = ioc.getBean(UserController.class);
            userController.saveUser();
        }
    }

### 2.3 基于注解管理bean ###

**依赖 pom.xml**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.atguigu.spring</groupId>
        <artifactId>spring_ioc_annotation</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.3.1</version>
            </dependency>
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
    
        <properties>
            <maven.compiler.source>19</maven.compiler.source>
            <maven.compiler.target>19</maven.compiler.target>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
    
    </project>

#### 2.3.1 标记与扫描 ####

##### 2.3.1.1 标记 #####

> **标记组件常用的注解:**  
> 1、@Component：将类标识为普通组件  
> 2、@Controller：将类标识为控制层组件  
> 3、@Service：将类标识为业务层组件  
> 4、@Repository：将类标识为持久层组件  
> **注意：**  
> 四个注解没有本质的区别，功能都是一样的，只是为了给程序开发人员可观。

**控制层组件**

@Controller
    public class UserController {
        
    }

**业务层接口**

public interface UserService {
        
    }

**业务层组件**

@Service
    public class UserServiceImpl implements UserService {
        
    }

**持久层接口**

public interface UserDao {
        
    }

**持久层组件**

@Repository
    public class UserDaoImpl implements UserDao {
        
    }

##### 2.3.1.2 扫描 #####

> **扫描组件的三种方式：**  
> 1、最基本的扫描方式  
> 2、指定要排除的组件  
> 3、仅扫描指定组件

**1、最基本的扫描方式**

<context:component-scan base-package="com.atguigu.spring"></context:component-scan>

**2、指定要排除的组件**

<context:component-scan base-package="com.atguigu.spring">
            
            
            
            
            
        </context:component-scan>

**3、仅扫描指定组件**

<context:component-scan base-package="com.atguigu.spring" use-default-filters="false">
            
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>

##### 2.3.1.3 bean的id #####

> **bean的id的设置**  
> 1、默认的bean的id  
> 2、自定义的bean的id

/**
         * 1、默认bean的id：
         *  通过注解+扫描所配置的bean的id，默认值为类的小驼峰，即类名的首字母为小写的结果值
         * 2、自定义bean的id：
         *  可通过标识组件的注解的value属性设置自定义的bean的id
         */
        @Test
        public void test(){
        
            ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");
            // userController为默认的bean的id
            UserController userController = ioc.getBean("userController",UserController.class);
            System.out.println(userController);
            // service为自定义的bean的id
            UserService userService = ioc.getBean("service",UserService.class);
            System.out.println(userService);
            UserDao userDao = ioc.getBean(UserDao.class);
            System.out.println(userDao);
        }

#### 2.3.2 基于注解的自动装配 ####

> 在UserController中声明UserService对象  
> 在UserServiceImpl中声明UserDao对象

> 在成员变量上直接标记@Autowired注解即可完成自动装配，不需要提供setXxx()方法。以后我们在项  
> 目中的正式用法就是这样。

**@Autowired注解的工作流程**  
![在这里插入图片描述][f82268c0952e45ac902bc277afc64f92.png]

**UserController**

package com.atguigu.spring.controller;
    
    import com.atguigu.spring.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController {
        
        //（1）@Autowired标识在成员变量上
        //@Autowired
        private UserService userService;
    
        //（2）@Autowired标识在set方法上
        //@Autowired
        //public void setUserService(UserService userService) {
        
        //    this.userService = userService;
        //}
    
        //（3）@Autowired标识在有参构造上
        @Autowired
        public UserController(UserService userService) {
        
            this.userService = userService;
        }
    
        public void saveUser(){
        
            userService.saveUser();
        }
    }

**UserService**

package com.atguigu.spring.service;
    
    
    public interface UserService {
        
        /**
         * 保存用户信息
         */
        void saveUser();
    }

**UserServiceImpl**

package com.atguigu.spring.service.impl;
    
    import com.atguigu.spring.dao.UserDao;
    import com.atguigu.spring.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service("service")
    public class UserServiceImpl implements UserService {
        
        @Autowired
        private UserDao userDao;
    
        @Override
        public void saveUser() {
        
            userDao.saveUser();
        }
    }

**UserDao**

package com.atguigu.spring.dao;
    
    public interface UserDao {
        
        /**
         * 保存用户信息
         */
        void saveUser();
    }

**UserDaoImpl**

package com.atguigu.spring.dao.impl;
    
    import com.atguigu.spring.dao.UserDao;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class UserDaoImpl implements UserDao {
        
        @Override
        public void saveUser() {
        
            System.out.println("保存成功");
        }
    }

**测试类**

package com.atguigu.spring.test;
    
    import com.atguigu.spring.controller.UserController;
    import com.atguigu.spring.dao.UserDao;
    import com.atguigu.spring.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class IOCByAnnotationTest {
        
        /**
         * 四个注解：
         *  1、@Component：将类标识为普通组件
         *  2、@Controller：将类标识为控制层组件
         *  3、@Service：将类标识为业务层组件
         *  4、@Repository：将类标识为持久层组件
         * 四个注解没有本质的区别，功能都是一样的，只是为了给程序开发人员可观。
         *
         * 1、默认bean的id：
         *  通过注解+扫描所配置的bean的id，默认值为类的小驼峰，即类名的首字母为小写的结果值
         * 2、自定义bean的id：
         *  可通过标识组件的注解的value属性设置自定义的bean的id
         *
         * @Autowired:实现自动装配功能的注解
         * 1、@Autowired注解能够标识的位置：
         *  （1）标识在成员变量上，此时不需要来设置成员变量的set方法；
         *  （2）标识在set方法上；
         *  （3）标识为当前成员变量赋值的有参构造上；
         * 2、@Autowired注解的原理
         *  （1）默认通过byType的方式，在IOC容器中通过类型匹配某个bean为属性赋值；
         *  （2）若有多个类型匹配的bean，此时会自动转换为byName的方式来实现自动装配的效果；
         *      （即将要赋值的属性的属性名作为bean的id匹配某个bean来为当前属性赋值）
         *  （3）若byType和byName的方式都无法实现自动装配，
         *      即IOC容器中有多个类型匹配的bean，且这些bean的id和要赋值的属性的属性名都不一致。
         *      此时，抛出异常：NoUniqueBeanDefinitionException
         *  （4）此时可以在要赋值的属性上，添加一个注解@Qualifier(""),根据@Qualifier注解中指定的名称作为bean的id进行匹配
         *
         * 注意：若IOC容器中没有任何一个类型匹配的bean，此时抛出异常：NoSuchBeanDefinitionException
         *  在@Autowired注解中有个属性required，默认值为true，要求必须完成自动装配
         *  可以将required属性设置为false，此时能装配则装配，无法装配则使用属性的默认值
         */
        @Test
        public void test(){
        
            ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc-annotation.xml");
            UserController userController = ioc.getBean("userController",UserController.class);
            userController.saveUser();
        }
    }

--------------------

## 3. AOP ##

### 3.1 场景模拟 ###

### 3.2 代理模式 ###

### 3.3 AOP概念及相关术语 ###

### 3.4 基于注解的AOP ###

### 3.5 基于XML的AOP（了解） ###

--------------------

## 4. 声明式事务 ##

### 4.1 JdbcTemplate ###

### 4.2 声明式事务概念 ###

### 4.3 基于注解的声明式事务 ###

### 4.4 基于XML的声明式事务 ###

--------------------

[Spring]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2a78ead8e0634bb2bc7722e00dd0cde2.png
[824ea83cddfe4a129811cbd19b97ec39.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/9d5f5ada593a414093456281b38c328d.png
[f82268c0952e45ac902bc277afc64f92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/3fbe90d258d0468d9bf60293df7c2705.png