typora-root-url: file\新建文件夹

Spring5框架概述:

1. Spring是轻量级的JavaEE框架
2. Spring可以解决企业应用的开发复杂性
3. Spring有两个核心部分:IOC和Aop
   IOC:控制反转，把创建对象过程交给Spring进行管理
   Aop:面向切面，不修改源代码进行功能增
4. Spring特点:

• 方便解耦，简化开发
• Aop编程支持
• 方便程序测试
• 方便和其它框架进行整合
• 方便进行事务操作
• 降低API开发难度

Spring图解:

入门案例:

可以导入jar包，Maven则导入依赖

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.8</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.3.8</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.8</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>5.3.8</version>
  </dependency>
  <dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.1.1</version>
  </dependency>
</dependencies>

1->创建User类

package spring5;
public class User {
public void add(){
    System.out.println("add被执行");
}
}

2->创建bean1.xml配置文件（Maven需要创建在resources中）

<?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="spring5.User"></bean>
</beans>

3->test包下测试代码

package org.example;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring5.User;
/**
 * Unit test for simple User.
 */
public class UserTest
{
     @Test
 public void UserTest(){
         //1.加载spring配置文件
         ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
         //2.获取配置创建的对象
         User user=context.getBean("user",User.class);
         System.out.println(user);
         user.add();
     }
}

结果:

spring5.User@5fdcaa40
add被执行

IOC容器:

概念和原理：

1.什么是IOC？

• 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
• 使用IOC的目的：为了耦合度降低
• 做入门案列就是IOC的实现

2.IOC的底层原理

• xml的解析
• 工厂模式
• 反射

3.图解IOC底层原理

解耦合方式1：工厂模式

解耦合方式2:IOC

当UserDao的地址修改时，只需要修改配置文件

4.IOC接口:

1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

2.Spring提供IOC容器有两种方式:(两种接口)

• BeanFactory:IOC容器的基本实现，是Spring内部的使用接口，不提供开发人员进行使用

（加载配置文件时候不会创建对象，在获取对象使用时才会去创建）

• ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能,一般由开发人员进行使用

（加载配置文件时候就会把配置文件对象进行创建）

3.Application接口有实现类:crtl+H查看类的结构

IOC操作Bean管理(基于xml方式)

1.基于xml方式创建对象

<!--配置User对象创建-->
<bean id="user" class="spring5.User"></bean>

• 在spring配置文件中，使用bean标签，标签里添加对应的属性，就可以实现对象的创建
• 在bean标签有很多属性，介绍常用的属性
  • id属性：唯一标识(name功能大致相同,很少使用)
  • class属性：类全路径（包类路径）
• 在创建对象的时候，默认也是执行无参数的构造方法完成对象创建

2.基于xml方式注入属性

• 依赖注入，就是注入属性 （先创建对象，才能进行注入）

3.第一种注入方式：使用set方法进行注入

• 创建类，定义属性和对应的值

package spring5;
public class User {
    private String id;
    private String name;
    public void setId(String id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void add(){
    System.out.println("add被执行");
}
    public void testDemo(){
        System.out.println(id+"::"+name);
    }
}

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

<bean id="user" class="spring5.User">
    <!--   使用property完成属性注入
              name:类里面的名称
              value:向属性注入的值
     -->
    <property name="id" value="3"></property>
    <property name="name" value="刘德华"></property>
</bean>

• 测试

package org.example;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring5.User;
public class UserTest
{
     @Test
 public void UserTest(){
         //1.加载spring配置文件
         ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
         //2.获取配置创建的对象
         User user=context.getBean("user",User.class);
         System.out.println(user);
         user.testDemo();
     }
}

4.第二种注入方式：使用有参数构造进行注入

• 创建类，定义属性值，和实现有参构造方法

package spring5;
public class Book {
    private String bookname;
    private String author;
    public Book(String bookname, String author) {
        this.bookname = bookname;
        this.author = author;
    }
    public void testDemo(){
        System.out.println(bookname+"::"+author);
    }
}

• 在spring配置中进行配置

<bean id="book" class="spring5.Book">
    <!--   constructor-arg 也可以根据index索引进行配置     -->
    <constructor-arg name="bookname" value="山海经"></constructor-arg>
    <constructor-arg name="author" value="老舍"></constructor-arg>
</bean>

• 测试

package org.example;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring5.Book;
import spring5.User;
public class BookTest {
    @Test
    public void BookTest(){
        //1.加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置创建的对象
        Book book=context.getBean("book", Book.class);
        System.out.println(book);
        book.testDemo();
    }
}

5.p名称空间注入（了解）

使用p名称空间注入，可以简化基于xml配置方式（对set进行注入）

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-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">

• 进行属性注入，在bean标签里面进行操作

<!--配置User对象创建-->
<bean id="user" class="spring5.User" p:id="0101" p:name="吴亦凡我的超人" >

6.IOC操作Bean管理

注入属性-(xml中注入其他类型属性）

字面量

• null值

<property name="address" >
    <null></null>
</property>

• 属性值包含特殊符号

<property name="address" >
    <value><![CDATA[<<南京>>]]></value>
</property>

或者使用转义符

注入属性-(外部bean)

• 创建Service层

package service;
import Dao.Dao;
public class Service {
    //创建Dao属性，生成set方法
    private Dao Dao;
    public void setDao(Dao dao) {
        Dao = dao;
    }
    public void test(){
        System.out.println("service被调用...");
//        //原始方式:创建Dao对象,调用方法
//        Dao dao=new DaoImpl();
//        dao.DaoTest();
        Dao.DaoTest();
    }
}

• 创建Dao接口和Dao实现类

package Dao;
public interface Dao {
    public void DaoTest();
}

package Dao;
public class DaoImpl implements Dao{
    @Override
    public void DaoTest() {
        System.out.println("dao被调用...");
    }
}

• 在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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="service" class="service.Service">
        <!--   注入Dao对象
                name属性值：类里面的属性名称
                href属性值：创建Dao对象bean标签的id值
        -->
        <property name="dao" ref="daoImpl"></property>
    </bean>
    <bean id="daoImpl" class="Dao.DaoImpl"></bean>
</beans>

• Service测试类:

package org.example;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.Service;
import spring5.Book;
public class ServiceTest {
    @Test
    public void ServiceTest(){
        //1.加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
        //2.获取配置创建的对象
        Service service=context.getBean("service", Service.class);
        service.test();
    }
}

运行结果:

service被调用…
dao被调用…

注入属性-(内部bean和级联赋值)

一对多关系：部门和员工

一个部门有多个员工，一个员工属于一个部门

部门是一，员工是多

• 创建Dept和Emp类

package company;
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }
    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

package company;
public class Emp {
    private String ename;
    private String sex;
    private Dept dept;
    public void setEname(String ename) {
        this.ename = ename;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + '\'' +
                ", sex='" + sex + '\'' +
                ", dept=" + dept +
                '}';
    }
}

• 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 内部配置   -->
    <bean id="emp" class="company.Emp">
        <property name="ename" value="马化腾"></property>
        <property name="sex" value="男"></property>
        <property name="dept">
            <bean id="dept" class="company.Dept">
                <property name="dname" value="扫地僧部门"></property>
            </bean>
        </property>
    </bean>
</beans>

Emp测试:

package org.example;
import company.Emp;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.Service;
public class CompanyTest {
    @Test
    public void CompanyTest(){
        //1.加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
        //2.获取配置创建的对象
        Emp emp=context.getBean("emp", Emp.class);
        System.out.println(emp);
    }
}

结果：

Emp{ename=’马化腾’, sex=’男’, dept=Dept{dname=’扫地僧部门’}}

注入属性-（级联复制）

方式一:

• 修改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"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <!-- 级联复制   -->
  <bean id="emp" class="company.Emp">
      <property name="ename" value="马化腾"></property>
      <property name="sex" value="男"></property>
      <property name="dept" ref="dept"></property>
  </bean>
  <bean id="dept" class="company.Dept">
      <property name="dname" value="扫地僧部门"></property>
  </bean>
  </beans>

Emp测试:

package org.example;
import company.Emp;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class companyTest2 {
    @Test
    public void CompanyTest2(){
        //1.加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        //2.获取配置创建的对象
        Emp emp=context.getBean("emp", Emp.class);
        System.out.println(emp);
    }
}

结果：
Emp{ename=’马化腾’, sex=’男’, dept=Dept{dname=’扫地僧部门’}}

方式二:

• 修改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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 级联复制   -->
    <bean id="emp" class="company.Emp">
        <property name="ename" value="马化腾"></property>
        <property name="sex" value="男"></property>
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="安保部门"></property>
    </bean>
    <bean id="dept" class="company.Dept">
        <property name="dname" value="扫地僧部门"></property>
    </bean>
</beans>

但在Emp中需要设置Dept的get方法，才能得到dept属性值进行设置

Emp:

public Dept getDept() {
    return dept;
}

7.注入集合类型属性一

• 注入数组类型，List,Map,Set 属性

package spring5;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Stu {
    //1.数组类型属性
    private String[] courses;
    //2.list集合类型属性
    private List<String> list;
    //3.map集合类型属性
    private Map<String,String> maps;
    //4.set集合类型属性
    private Set<String> sets;
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }
}

• 再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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="stu" class="spring5.Stu">
    <property name="courses">
        <array>
            <value>001号选手</value>
            <value>格言:你18张牌能秒我?</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>卢本伟</value>
            <value>马飞飞</value>
        </list>
    </property>
    <property name="maps">
        <map>
            <entry key="大司马" value="马氏三角杀创始人"></entry>
            <entry key="PDD" value="反向抽烟"></entry>
        </map>
    </property>
    <property name="sets">
        <set>
            <value>Java</value>
            <value>爪洼</value>
        </set>
    </property>
</bean>
</beans>

• 测试

package org.example;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import spring5.Stu;
public class ConllectionTest {
    @Test
    public void collectionTest(){
        //1.加载Spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean5.xml");
        //2.获取配置创建的对象
        Stu stu = context.getBean("stu", Stu.class);
        stu.test();
    }
}

运行结果:

[001号选手, 格言:你18张牌能秒我?]
[卢本伟, 马飞飞]
{大司马=马氏三角杀创始人, PDD=反向抽烟}
[Java, 爪洼]

8.向集合中注入对象

• Stu类进行修改,在实现Course类

package spring5;
public class Course {
    private String cname;
    private String edit;
    public void setCname(String cname) {
        this.cname = cname;
    }
    public void setEdit(String edit) {
        this.edit = edit;
    }
    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                ", edit='" + edit + '\'' +
                '}';
    }
}

package spring5;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Stu {
    //1.数组类型属性
    private String[] courses;
    //2.list集合类型属性
    private List<String> list;
    //3.map集合类型属性
    private Map<String,String> maps;
    //4.set集合类型属性
    private Set<String> sets;
    //5.List集合对象
    private List<Course> course;
    public void setCourses(String[] courses) {
        this.courses = courses;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public void setCourse(List<Course> course) {
        this.course = course;
    }
    public void test(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(course);
    }
}

• 配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="stu" class="spring5.Stu">
    <property name="courses">
        <array>
            <value>001号选手</value>
            <value>格言:你18张牌能秒我?</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>卢本伟</value>
            <value>马飞飞</value>
        </list>
    </property>
    <property name="maps">
        <map>
            <entry key="大司马" value="马氏三角杀创始人"></entry>
            <entry key="PDD" value="反向抽烟"></entry>
        </map>
    </property>
    <property name="sets">
        <set>
            <value>Java</value>
            <value>爪洼</value>
        </set>
    </property>
    <property name="course">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>
    <bean id="course1" class="spring5.Course">
        <property name="cname" value="C#"></property>
        <property name="edit" value="成都大学出版社"></property>
    </bean>
    <bean id="course2" class="spring5.Course">
        <property name="cname" value="C++"></property>
        <property name="edit" value="成都大学出版社"></property>
    </bean>
</beans>

9.把集合注入部分提取出来

• 创建Book类进行演示

package demo;
import java.util.List;
public class Book {
    private List<String> name;
    public void setName(List<String> name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name=" + name +
                '}';
    }
}

• 再spring配置文件中添加util命名空间

<?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: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">

• 使用util标签完成list集合注入

    <!-- 1.提取List集合类型属性注入   -->
    <util:list id="booklist">
        <value>九阳神功</value>
        <value>辟邪剑法</value>
        <value>降龙十八掌</value>
    </util:list>
<bean id="book" class="demo.Book">
    <property name="name" ref="booklist"></property>
</bean>
</beans>

• 测试

package demotest;
import demo.Book;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
    @Test
    public void collectionTest(){
        //1.加载Spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置创建的对象
        Book book=context.getBean("book",Book.class);
        System.out.println(book);
    }
}

IOC操作Bean管理(FactoryBean)

Spring有两种类型bean，一种普通bean，另一种工厂bean（FactoryBean）

• 普通Bean：在配置文件中定义bean类型就是返回类型
• 工厂bean：在配置文件中定义bean类型可以和返回类型不一样
  1. 第一步：创建类，让这个类作为工厂bean，实现接口FactoryBean
  2. 第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型
  • 举例

创建MyBean类，并实现接口:

package demo;
import org.springframework.beans.factory.FactoryBean;
public class MyBean implements FactoryBean<Course> {
    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("辟邪剑法");
        course.setEdit("成都大学出版社");
        return course;
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
}

在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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="mybean" class="demo.MyBean"></bean>
</beans>

测试：

package demotest;
import demo.Book;
import demo.Course;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyBeanTest {
    @Test
    public void collectionTest(){
        //1.加载Spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
        //2.获取配置创建的对象
        Course course=context.getBean("mybean",Course.class);
        System.out.println(course);
    }
}

IOC的Bean管理(作用域)

• 在spring中有单实例和多实例
• 在spring中默认情况下为单实例

测试：

package demotest;
import demo.Book;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BookTest {
    @Test
    public void collectionTest(){
        //1.加载Spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        //2.获取配置创建的对象
        Book book1=context.getBean("book",Book.class);
        Book book2=context.getBean("book",Book.class);
        System.out.println(book1);
        System.out.println(book2);
    }
}

测试结果:

demo.Book@55fe41ea
demo.Book@55fe41ea

地址相同姿势单实例

• 如何设置单实例还是多实例
  Scope属性值

  • 第一个值 默认值,singleton,表示单实例对象
  • 第二个值 prototype,表示是多实例对象

    <bean id="book" class="demo.Book" scope="prototype">
    <property name="name" ref="booklist"></property>
    </bean>

    此时的测试结果的2个book不一样，测试多实例对象

• singleton和prototype的区别

  • singleton单实例，prototype多实例
  • 设置scope值是singleton时候，加载spring配置文件的时候创建单实例对象，设置scope值是prototype的时候，不是在加载spring配置文件时候创建对象，在调用getBean方法的时候创建

IOC操作Bean管理(Bean的生命周期)

• 生命周期：从对象创建到对象销毁的过程
• bean的生命周期
  1. 通过构造器创建bean实例（无参数构造）
  2. 为bean的属性设置值和对其它bean引用（调用set方法）
  3. 调用bean的初始化的方 法（需要进行配置初始化的方法）
  4. bean可以使用了（对象获取到了）
  5. 当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
• 演示生命周期:

创建Order类:

package demo;
public class Order {
    private String ordername;
    public void setOrdername(String ordername) {
        this.ordername = ordername;
        System.out.println("第二步 执行set方法");
    }
    public Order() {
        System.out.println("第一步 执行无参构造方法");
    }
    //创建执行的初始化方法
    public void initMethod(){
        System.out.println("第三步 执行初始化方法");
    }
    //创建执行的销毁方法
    public void destoryMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}

在spring配置文件中进行配置：

<bean id="order" class="demo.Order" init-method="initMethod" destroy-method="destoryMethod">
    <property name="ordername" value="EDG冠军!!!"></property>
</bean>

测试：

package demotest;
import demo.Course;
import demo.Order;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class OrderTest {
    @Test
    public void collectionTest(){
        //1.加载Spring配置文件
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
        //2.获取配置创建的对象
        Order order=context.getBean("order", Order.class);
        System.out.println("第四步 获取创建的bean实例对象");
        System.out.println(order);
        //手动让bean实例销毁
        context.close();
    }
}

运行结果:

第一步 执行无参构造方法
第二步 执行set方法
第三步 执行初始化方法
第四步 获取创建的bean实例对象
demo.Order@48f2bd5b
第五步 执行销毁方法

• bean后置处理器
  • bean的生命周期会改变
    1. 通过构造器创建bean实例（无参数构造）
    2. 为bean的属性设置值和对其它bean引用（调用set方法）
    3. 把bean实例传递bean后置处理器的方法
    4. 调用bean的初始化的方 法（需要进行配置初始化的方法）
    5. 把bean实例传递bean后置处理器的方法
    6. bean可以使用了（对象获取到了）
    7. 当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
• 演示后置处理器
  1. 创建类，实现接口BeanPostProcessor,创建后置处理器 ```java package demo;

import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.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;
}

}

2.在spring中配置后置处理器 
```xml
<!-- 配置后置处理器-->
<bean id="mybeanpost" class="demo.MyBeanPost"></bean>

运行测试结果:
第一步 执行无参构造方法
第二步 执行set方法
初始化之前执行的方法
第三步 执行初始化方法
初始化之后执行的方法
第四步 获取创建的bean实例对象
demo.Order@47eaca72 第五步 执行销毁方法
则生命周期被改变

IOC操作Bean管理(xml自动装配)

• 自动装配：根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

• 演示自动装配

   <!--实现自动装配
           bean标签属性autowire，配置自动装配
           autowire属性常用2个值:
               byName根据属性名称注入，注入值bean的id值和类属性名称一样
               byType根据属性类型注入
   -->

  • 根据属性名自动注入

    <bean id="stu" class="demo.Stu" autowire="byName"></bean>
    <bean id="course" class="demo.Course">
    <property name="edit" value="成都大学"></property>
    <property name="cname" value="C++"></property>
    </bean>

  • 根据属性类型自动注入

    <bean id="stu" class="demo.Stu" autowire="byType"></bean>
    <bean id="course" class="demo.Course">
    <property name="edit" value="成都大学"></property>
    <property name="cname" value="C++"></property>
    </bean>

IOC操作Bean属性(外部属性文件)

• 直接配置数据库信息

  • 配置druid连接池
  • maven中加入druid依赖

  • 配置数据库连接池

    1. 直接配置

       <!--直接配置druid连接池-->
       <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="LJLljl20020728.+"></property>
       </bean>

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

       • 创建外部属性文件,properties格式文件，写数据库信息

         pro.driverClass=com.mysql.jdbc.Driver
         pro.url=jdbc:mysql://localhost:3306/userDb
         pro.username=root
         pro.password=LJLljl20020728.+

       • 把外部properties属性文件引入到spring配置文件中

         1. 引入context名称空间

            <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">

         2. 在spring中使用标签引入外部属性文件

            <!--引入外部属性文件 -->
            <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
            <!--如果使用 Spring Framework 5.2 或更高版本，您可以使用替代方法从属性文件加载变量-->
            <bean class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer">
            <property name="location">
            <value>classpath:jdbc.properties</value>
            </property>
            </bean>
            <!--配置连接池-->
            <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${prop.driverClass}"></property>
            <property name="url" value="${pro.url}"></property>
            <property name="username" value="${pro.username}"></property>
            <property name="password" value="${pro.password}"></property>
            </bean>

IOC操作Bean管理注解方式(基于注解方式)

• 什么是注解
  • 注解是代码的特殊标记，格式，@注解名称(属性名称=属性值，属性名称=属性值…)
  • 使用注解，注解作用在类上面，方法上面，属性上面
  • 使用注解的目的：简化xml配置
• Spring针对Bean管理中创建对象提供注解
  • @Component（普通组件）
  • @Service（业务逻辑层）
  • @Controller（控制层）
  • @Repository（DAO层）

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

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

  • maven添加spring-aop依赖

  • 开启组件扫描

    <!--开启组件扫描
       1.如果扫描多个包，多个包使用都好隔开
       2.扫描包上层目录
    -->
    <context:component-scan base-package="demo1"></context:component-scan>

  • 创建类，在类上面添加创建对象注解

    //在注解里面value属性值可以省略不写
    //默认值是类名称时，首字母小写
    //UserService==userService
    @Component  //<bean id="userService" class="...">
    public class UserService {
    public void add(){
       System.out.println("正在执行UserService");
    }
    }

IOC操作Bean管理注解方式(扫描组件配置)

• 开启组件扫描配置
  ```xml

<a name="6206c331"></a>
## IOC操作Bean管理注解方式(基于注解方式实现属性注入)
-  @Autowired:根据**属性类型**进行自动装配 
   -  把service和dao对象创建，在service和dao类添加创建对象注解 
   -  把service注入dao对象，在service类添加dao对象属性，在属性上面使用注解  
```java
//在注解里面value属性值可以省略不写
//默认值是类名称时，首字母小写
//UserService==userService
@Service  //<bean id="userService" class="...">
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired
    private UserDao userDao;
    public void add(){
        System.out.println("正在执行UserService");
    }
}

• @Qualifier:根据属性名称进行注入

  • 这个@Qualifier注解的使用，和上面@Autowired一起使用

    @Service //<bean id="userService" class="...">
    public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired  //根据类型进行注入
    @Qualifier(value = "userDaoImpl")//根据名称进行注入
    private UserDao userDao;
    public void add(){
      System.out.println("正在执行UserService");
      userDao.add();
    }

• @Resource:根据类型注入，可以根据名称注入 (属于javax扩展包)

  • @Service //<bean id="userService" class="...">
    public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    //    @Autowired  //根据类型进行注入
    //    @Qualifier(value = "userDaoImpl")//根据名称进行注入
    //    private UserDao userDao;
    //    @Resource   //根据类型注入
    @Resource(name = "userDaoImpl") //根据名称进行注入
    private UserDao userDao;
    public void add(){
     System.out.println("正在执行UserService");
     userDao.add();
    }

• @Value:注入普通类型属性

  • @Value(value = "卢本伟牛皮")
    private String name;

完全注解开发：

• 创建配置类，代替xml文件
  • ```java @Configuration //作为配置类，替代xml文件 @ComponentScan(basePackages = {“demo1”,”dao”}) public class springconfig {

}

-  创建测试类 
   -   
```java
@Test
public void collectionTest(){
    //1.加载Spring配置文件
    ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
    //2.获取配置创建的对象
    UserService userService = context.getBean("userService", UserService.class);
    System.out.println(userService);
    userService.add();
}

AOP：

概念和原理

1.什么是AOP？

• 面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使的业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发的效率
• 通俗来讲:通过不修改源代码的方式，在主干功能里面添加新的功能
• 举例说明:
  

2.AOP底层原理

• 有两种动态代理情况
  • 有接口情况，使用JDK动态代理(创建接口实现类代理对象，增强类的方法)
    
  • 没有接口情况，使用CGLIB动态代理 (创建子类的代理对象，增强类的方法)
    

3.使用JDK动态代理，使用Proxy类里面的方法创建代理对象

• 使用JDK动态代理，使用Proxy类里面的方法创建代理对象
  
• 调用newProxyInstance方法
  
  方法有三个参数:
  • 第一参数：类加载器
  • 第二参数：增强方法所在的类，这个类实现的接口，支持多个接口
  • 第三参数：实现这个接口InvocationHandler，创建代理对象，写增强的方法
• 编写JDK动态代理代码
  • 创建接口，定义方法
    ```java package dao;

public interface BookDao { public int add(int a,int b); public String update(String id); }

   -  常见接口实现类,实现方法  
```java
package dao;
public class BookDaoImpl implements BookDao{
    @Override
    public int add(int a, int b) {
        return a+b;
    }
    @Override
    public String update(String id) {
        return id;
    }
}

• 使用Proxy类创建接口代理对象
  ```java package demo1;

import dao.BookDao; import dao.BookDaoImpl;

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.Arrays;

public class JDKProxy { public static void main(String[] args) { //创建接口实现类代理 Class[] interfaces = {BookDao.class};

// Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() { // @Override // public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // return null; // } // }); BookDaoImpl bookDao = new BookDaoImpl(); BookDao dao = (BookDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new BookDaoProxy(bookDao)); int result=dao.add(1,2); System.out.println(“result”+result); } } //创建代理对象代码 class BookDaoProxy implements InvocationHandler{ //1.把创建的是谁的代理对象，把谁传递过来 //有参构造传递 private Object obj; public BookDaoProxy(Object obj){ this.obj=obj; } //增强的逻辑 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //方法之前 System.out.println(“方法之前执行…”+method.getName()+”:传递的参数…”+ Arrays.toString(args)); //被增强的方法执行 Object o = method.invoke(obj, args); //方法之后执行 System.out.println(“方法之后执行…”+obj); return o; } }

   -  运行结果:<br />方法之前执行...add:传递的参数...[1, 2]<br />add方法正在执行...<br />方法之后执行...dao.BookDaoImpl[@17a7cec2 ](/17a7cec2 ) <br />result3 
<a name="c371280e"></a>
## AOP（术语）
- 连接点 
   - 类里面**哪些方法可以被增强**，这些方法称为连接点
- 切入点 
   - 实际**被真正增强的方法**，称为切入点
- 通知（增强） 
   - **实际增强的逻辑部分**称为通知（增强）
   - 通知有多种类型 
      - 前置通知
      - 后置通知
      - 环绕通知
      - 异常通知
      - 最终通知   finally
- 切面 
   - 是动作 
      - 把**通知应用到切入点过程**
<a name="880823a3"></a>
## AOP操作(准备):
-  Spring框架一般都是基于**AspectJ**实现AOP操作 
   - AspectJ**不是Spring组成部分**，**独立AOP框架**，一般把AspectJ和Spring框架一起使用，进行AOP操作
-  基于AspectJ实现AOP操作 
   - 基于**xml配置文件**实现
   - 基于**注解的方式**实现（一般使用注解，较为简单）
-  在项目工程中引入AOP相关的jar包 
   -   
```xml
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.7.0</version>
</dependency>
<dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>1.0</version>
</dependency>
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

• 切入点表达式
  • 切入点表达式作用，知道对哪个类型里面的哪个方法进行增强
  • 语法结构
    • execution([权限修饰符] [返回类型] [类全路径] [方法名称] ([参数类型]) )
    • 举例一:对demo.BookDao类里面的add进行增强
      execution(* demo.BookDao.add(..))
    • 举例二:对demo.BookDao类里面所有的方法进行增强
      execution( demo.BookDao.(..))
    • 举例三:对demo所有类中的所有方法进行增强
      execution( demo. . *(..))

AOP操作(AspectJ注解)

• 创建类

  public class User {
   public void add(){
       System.out.println("add正在执行...");
   }

• 创建增强类

  • 在增强类里面，创建方法，让不同方法代替不同的通知类型

    //增强的类
    public class UserProxy {    //User代理对象
    public void Before(){
      System.out.println("before正在执行...");
    }

• 进行通知的配置

  • 在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"
     xmlns:aop="http://www.springframework.org/schema/aop"
     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
                          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启注释扫描-->
    <context:component-scan base-package="anpanno"></context:component-scan>
    </beans>

  • 如果完全使用注解开发，则创建配置类

    @Configuration
    @ComponentScan(basePackages = {"anpanno"})
    @EnableAspectJAutoProxy(proxyTargetClass = true)
    public class UserConfig {
    }

  • 使用注释创建User和UserProxy对象

    @Component
    public class User {

    @Component
    //增强的类
    public class UserProxy {

  • 在增强类上面添加注解@Aspect

    @Component
    @Aspect
    //增强的类
    public class UserProxy {

  • 在spring配置文件中开启生成代理对象

    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

• 配置不同类型的通知

  • 在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

    @Component
    @Aspect
    //增强的类
    public class UserProxy {    //User代理对象
    //前置通知
    //@Before注释表示前置通知
    @Before(value = "execution(* anpanno.User.add(..))")
    public void before(){
      System.out.println("before正在执行...");
    }
    //最终通知
    //@After注释表示最终通知，不管有没有异常都会执行
    @After(value = "execution(* anpanno.User.add(..))")
    public void after(){
      System.out.println("after正在执行...");
    }
    //异常通知
    //@AfterThrowing注释表示异常通知，当有异常时才会执行
    @AfterThrowing(value = "execution(* anpanno.User.add(..))")
    public void afterThrowing(){
      System.out.println("afterThrowing正在执行...");
    }
    //后置通知
    //@AfterReturning(返回通知)注释表示后置通知，当有异常时不会执行
    @AfterReturning(value = "execution(* anpanno.User.add(..))")
    public void afterReturning(){
      System.out.println("afterReturning正在执行...");
    }
    //环绕通知
    //Around@注释表示环绕通知
    @Around(value = "execution(* anpanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
      System.out.println("环绕之前...");
      //被增强的方法执行
      proceedingJoinPoint.proceed();
      System.out.println("环绕之后...");
    }
    }

• 测试：
  运行结果: spring5此版本的通知顺序如下
  环绕之前…
  before正在执行…
  add正在执行…
  afterReturning正在执行…
  after正在执行…
  环绕之后…
  当发生异常时，运行结果如下:
  环绕之前…
  before正在执行…
  afterThrowing正在执行…
  after正在执行…

  public class AnpannoTest {
   @Test
   public void AnpannoTest(){
       ApplicationContext applicationContext=new ClassPathXmlApplicationContext("User.xml");
       User user=applicationContext.getBean("user",User.class);
       user.add();
   }

• 相同切入点进行抽取

  @Component
  @Aspect
  //增强的类
  public class UserProxy {    //User代理对象
   //对相同切入点进行抽取
   @Pointcut(value = "execution(* anpanno.User.add(..))")
   public void pointdemo(){
   }
   //前置通知
   //@Before注释表示前置通知
   @Before(value = "pointdemo()")
   public void before(){
       System.out.println("before正在执行...");
   }
   //最终通知
   //@After注释表示最终通知，不管有没有异常都会执行
   @After(value = "pointdemo()")
   public void after(){
       System.out.println("after正在执行...");
   }
   //异常通知
   //@AfterThrowing注释表示异常通知，当有异常时才会执行
   @AfterThrowing(value = "pointdemo()")
   public void afterThrowing(){
       System.out.println("afterThrowing正在执行...");
   }
   //后置通知
   //@AfterReturning(返回通知)注释表示后置通知，当有异常时不会执行
   @AfterReturning(value = "pointdemo()")
   public void afterReturning(){
       System.out.println("afterReturning正在执行...");
   }
   //环绕通知
   //Around@注释表示环绕通知
   @Around(value = "pointdemo()")
   public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
       System.out.println("环绕之前...");
       //被增强的方法执行
       proceedingJoinPoint.proceed();
       System.out.println("环绕之后...");
   }
  }

• 有多个增强类多同一种方法进行增强，设置增强优先级

  • 在增强类上面添加注解@Order(数字类型值),数字类型值越小优先级越高

    @Component
    @Aspect
    @Order(1)
    public class PersonProxy {