Spring入门【自用笔记】_为什么beanfactory加载配置文件时不会创建对象-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44755051/article/details/122660266

一. Spring概念

Spring是一个轻量级的J2EE框架，可以解决企业应用开发的复杂性。

Spring有两个核心部分，IOC和AOP。

（1）IOC：控制反转。把创建对象的过程交给Spring进行管理。

（2）AOP：面向切面。不修改源代码的情况下，进行功能增强。

Spring的特点：

（1）方便解耦，简化开发。

（2）Aop编程支持。

（3）方便程序测试。

（4）方便和其他框架进行整合。

（5）方便进行实务操作。

（6）降低JAVA EE API 使用难度。

1.1 入门案例

① 下载入门项目代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lwVGQMgy-1642959089932)(X:\Users\Administrator\Desktop\assets\image-20220105140643155.png)]

② IDEA创建JAVA项目

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CgHcxYmx-1642959089934)(X:\Users\Administrator\Desktop\assets\image-20220105141428668.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-03KhVc4R-1642959089935)(X:\Users\Administrator\Desktop\assets\image-20220105142121783.png)]

③ 引入相关依赖。导入Spring5相关jar包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zxVUERhb-1642959089936)(X:\Users\Administrator\Desktop\assets\image-20220105142406721.png)]

Beans 和 Core 对应 IOC

Context对应上下文

Expression对应表达式

到libs中找到对应的jar包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QnWXz9Ij-1642959089937)(X:\Users\Administrator\Desktop\assets\image-20220105142700818.png)]

还有一个commons-logging-1.1.1.jar

复制到项目的lib文件夹中，然后导入相关依赖。

File --> Project Structure --> Modules --> Dependencies --> 点击加号 --> JAR to directories

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GfGVwVQP-1642959089938)(X:\Users\Administrator\Desktop\assets\image-20220105143352912.png)]

④ 创建普通类，在这个类创建普通方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-is2xg2NO-1642959089940)(X:\Users\Administrator\Desktop\assets\image-20220105143922932.png)]

⑤ 创建Spring配置文件，在配置文件中配置创建的对象

（1）Spring配置文件使用xml格式

在src文件夹下创建xml文件，命名为bean1.xml

xml文件中输入以下代码：

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

⑥ 测试代码编写

src路径下建一个test包，专门用于测试。

新建测试类 TestSpring5.java，写下测试代码

package com.atguigu.spring5.testdemo;

import com.atguigu.spring5.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5 {
    // Test包一开始没有，快捷键alt+enter导入
    @Test
    public void testAdd(){
        // 1. 加载配置文件（xml）
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2. 获取配置创建的对象
        // 下面这句话是user = context.getBean("user",User.class).var转换来的 创建一个User对象，alt+enter导入User类
        User user = context.getBean("user", User.class);

        System.out.println(user);
        user.add();
    }
}

⑦运行测试代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G3MIpzdN-1642959089942)(X:\Users\Administrator\Desktop\assets\image-20220105150042117.png)]

可见成功获取了Spring配置创建的对象

二. IOC容器

2.1 IOC底层原理

什么是IOC？

IOC也称为控制反转，也就是把对象创建和对象之间的调用过程交给Spring进行管理，从而达到降低耦合度的目的。上述的入门案例就是IOC的简单实现。

IOC底层原理

① XML解析、工厂模式、反射

原始方式，在一个类中调用另一个类的普通方法是这样的：

class UserService(){                       		 class UserDao(){
	execute(){										add(){
		UserDao dao = new UserDao();						............
		dao.add();				
	}												}
}												 }

这种方法虽然很直观地可以看出对象之间的调用关系，但是存在一个很致命的缺点，即代码的耦合度太高了。如果UserDao的方法变了，UserService也必须跟着变。

要降低代码的耦合度，提出了工厂模式。

class UserService(){                       		 class UserDao(){
	execute(){										add(){
		UserDao dao = UserFactory.getDao();				  ............
		dao.add();				
	}												}
}												 }

//新建工厂类
class UserFactory(){
    public static UserDao getDao(){
        return new UserDao();
    }
}

通过一个工厂类，完成了解耦的操作。降低了UserService和UserDao之间的耦合度。

这种方法虽然可以降低UserService和UserDao之间的耦合度，但是UserFactory的耦合度提高了，我们最终需要耦合度降到最低（完全没有耦合度是不可能的）。

怎么进一步降低耦合度呢？引入了IOC的概念。【XML解析，工厂模式，反射】

XML解析。

反射通过得到类的字节码文件，然后操作类的内容。得到class -> 类的内容。

IOC过程

第一步：xml配置文件，配置创建的对象。

<bean id="dao" class="com.atguigu.UserDao"></bean>

第二步：有service类和dao类

class UserFactory{
	public static UserDao getDao(){
		//1.xml解析
		String classValue = class属性值;//这里是xml解析完成的
		//2.通过反射创建对象
		Class clazz = Class.forName(classValue);
		return (UserDao)clazz.newInstance();
	}
}
//这样做的好处是即使对象的属性发生了修改，只需要修改一下xml配置文件就可以了，userFactory不用动。达到进一步降低耦合度的目的。

2.2 IOC接口（BeanFactory）

IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
Spring提供了IOC容器的两种实现方式。

（1）BeanFactory（IOC容器的基本实现，Spring内部使用的接口，开发中一般不使用）
```
// 1. 加载配置文件（xml）
        BeanFactory context =
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2. 获取配置创建的对象
        User user = context.getBean("user", User.class);
```
（2）ApplicationContext（BeanFactory的一个子接口，提供更多更强大的功能，面向开发人员）
```
// 1. 加载配置文件（xml）
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        // 2. 获取配置创建的对象
        User user = context.getBean("user", User.class);
```
共同点：

这两个接口的作用相似。都能够实现加载配置文件，然后获取配置创建的对象。

区别：

BeanFactory加载配置文件的时候不会创建对象，而是在获取对象或者使用对象的时候才创建。

ApplicationContext加载配置文件的时候就创建了对象。

开发中一般是在服务器启动的时候就完成对象的创建，而不是要用的时候再去创建。
ApplicationContext接口有实现类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fc73mfqL-1642959089945)(X:\Users\Administrator\Desktop\assets\image-20220105171709639.png)]

FileSystem这个实现类的特点是，configLocation写的是这个配置文件在磁盘中的位置。

ClassPath中的configLocation写的是配置文件的文件名字（默认路径在src下）。

2.3 IOC操作Bean管理（基于xml）

2.3.1 什么是Bean管理

Bean管理指的是两个操作：

（1）Spring创建对象

（2）Spring注入属性

Bean管理操作有两个方式：

（1）基于xml配置文件方式实现

（2）基于注解方式实现

2.3.2 基于xml方式创建对象

例如bean1.xml文件中的

 <bean id="user" class="com.atguigu.spring5.User"></bean>

（1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建。

（2）在bean标签中有很多属性：

id属性：给对象取一个标识，获取对象的时候使用该标识

class属性：类全路径（包类路径）

name属性：可以取特殊符号的标识，目前比较少用。

（3）创建对象的时候，默认也是执行无参数的构造方法完成对象创建。

2.3.3 基于xml方式注入属性

（1）DI：依赖注入，也就是注入属性。这是IOC中的一种实现方式，需要在创建对象的基础之上来注入。

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

第一步，创建类，定义属性和对应的set方法

//创建属性
    private String bname;
    private String bauthor;
//创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }
    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

第二步，在spring配置文件配置对象创建，配置属性注入

<!--set方法注入属性-->
<bean id="book" class="com.atguigu.spring5.Book">
     <!--使用property完成属性注入
         name:类里面的属性名称；
         value：向属性注入的值
     -->
    <property name="bname" value="三体：地球往事"></property>
    <property name="bauthor" value="刘慈欣"></property>
</bean>

第三步，测试：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X3hflAhc-1642959089947)(X:\Users\Administrator\Desktop\assets\image-20220105180926832.png)]

2 第二种注入方式：有参数构造注入

第一步，创建类，定义属性包括创建属性对应的有参数构造方法

/**
 * 使用有参数构造注入
 */
public class Orders {
    private String oname;
    private String address;

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

第二步，在spring配置文件配置对象创建，配置属性注入

    <!--有参数构造注入属性-->
    <bean id="orders" class="com.atguigu.spring5.Orders">
        <!--使用constructor-arg完成有参数构造的属性注入
            name:类里面的属性名称；
            value：向属性注入的值
        -->
        <constructor-arg name="oname" value="abc"></constructor-arg>
        <constructor-arg name="address" value="啦啦啦啦嗷"></constructor-arg>
        <!--或者可以用以下方式进行注入,0和1分别表示有参构造方法中的第一个和第二个参数-->
        <constructor-arg index="0" value="abc"></constructor-arg>
        <constructor-arg index="1" value="abc"></constructor-arg>
    </bean>

第三步，测试：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Db46leMk-1642959089948)(X:\Users\Administrator\Desktop\assets\image-20220105182306701.png)]

3 p名称空间注入

第一步：使用p名称空间注入，可以简化基于xml配置方式

<beans 
       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标签里进行操作

<bean id="book" class="com.atguigu.spring5.Book" p:bname="我的三体" p:bauthor="无名氏">
</bean>

4 注入控制和特殊符号

字面量

（1）null值

<bean id="book" class="com.atguigu.spring5.Book">
        <property name="bname" value="三体：地球往事"></property>
        <property name="bauthor" value="刘慈欣"></property>
    	<!--注入null值-->
        <property name="bpress">
            <null/>
        </property>
</bean>

（2）属性值包含特殊符号

<!-- 属性值包含特殊符号
     1.把<>进行转义
     2.把带特殊符号内容写到CDATA
-->
<property name="bpress" ><value><![CDATA[<<南京>>]]></value></property>

5 注入外部bean

什么叫做引入外部bean？

通过service层调用dao层。

（1）创建两个类service和dao

第一步，分别新建两个包，一个dao一个service

新建UserService类，用于调用dao的方法。

新建UserDao接口，并且新建UserDaoImpl，用于实现UserDao接口中定义的方法。

//UserService.java:
public class UserService {
    public void add(){
        System.out.println("service add...");
    }
}

//UserDao.java(interface)
public interface UserDao {
    public void update();
}

//UserDaoImpl.java:
public class UserDaoImpl implements UserDao {
    @Override
    public void update() {
        System.out.println("dao update...");
    }
}

（2）在service中来调用dao

public class UserService {
    public void add(){
        System.out.println("service add...");
        //1.常规方法创建UserDao对象并且调用
        UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}

（3）在spring配置文件中进行配置

UserService.java:
public class UserService {
    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void add(){
        System.out.println("service add...");
        //1.常规方法创建UserDao对象并且调用
        userDao.update();
    }
}

bean2.xml:
<!--1.service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <!--注入userDao对象
        name属性值：类里面属性的名称
        ref属性：创建userDao对象的bean标签的id值
    -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

（4）测试

TestBean.java:
public class TestBean {
    @Test
    public void testAdd(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");

        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

6 注入内部bean和级联赋值

（1）一对多关系：部门和员工

一个部门对应多个员工，一个员工属于一个部门。

部门是一，员工是多

（2）在实体类之间表示一对多关系

第一步：新建bean包，新建部门类和员工类，分别定义属性和Setter方法

Dept.java:
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

Emp.java:
public class Emp {
    private String ename;
    private String gender;

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

第二步，在员工类里表示员工属于某一个部门，用对象来表示

Emp.java:(add)
    //员工属于某一个部门，使用对象形式进行表示
    private Dept dept;
    public void setDept(Dept dept) {
        this.dept = dept;
    }

（3）在Spring配置文件中进行配置

新建bean3.xml，完成Dept和Emp

    <!--内部bean-->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!--先设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.atguigu.spring5.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>

（4）测试

Dept.java添加dname的toString方法使得有值输出

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }

Emp.java添加add方法，输出属性值；

    public void add(){
        System.out.println(ename + "::" + gender + "::" + dept);
    }

添加测试方法：

    public void testBean2(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean3.xml");

        Emp emp = context.getBean("emp", Emp.class);
        emp.add();
    }

注入属性级联赋值

（1）新建bean4，级联赋值

（写法一）
	<bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <property name="ename" value="Nancy"></property>
        <property name="gender" value="女"></property>

        <!--级联赋值-->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.atguigu.spring5.bean.Dept">
        <property name="dname" value="通信部"></property>
    </bean>
 
（写法二）
 生成dept的get方法
public Dept getDept() {
   return dept;
}

前提是需要提前生成get方法
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <property name="ename" value="Nancy"></property>
        <property name="gender" value="女"></property>

        <!--级联赋值-->
        <property name="dept.dname" value="网络部"></property>
    </bean>

（2）测试

同上。

7 xml注入集合属性

1、注入数组类型属性

2、注入List集合类型属性

3、注入Map集合

public class Stu {
    //1.数组类型属性
    private String[] courses;
    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    //2.List集合类型属性
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }

    //3.创建Map类型属性
    private Map<String,String> maps;
    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    //4.创建Set集合类型属性
    private Set<String> sets;
    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);
    }

XML文件配置

    <!--集合类型属性注入-->
    <bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>离散数学</value>
                <value>数据结构</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>小张</value>
            </list>
        </property>
        <!--map属性注入-->
        <property name="maps">
            <map>
                <entry key="MATH" value="math"></entry>
                <entry key="DAST" value="dast"></entry>
            </map>
        </property>
        <!--set类型属性注入-->
        <property name="sets">
            <set>
                <value>MYSQL</value>
                <value>Redis</value>
            </set>
        </property>
    </bean>

测试

public class TestSpring5Demo1 {
    @Test
    public void testCollection(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        context.getBean("stu", Stu.class);
        Stu stu = context.getBean("stu", Stu.class);
        stu.test();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9tCOXuOM-1642959089950)(X:\Users\Administrator\Desktop\assets\image-20220112160939203.png)]

4、在集合里面设置对象类型值

新建course类

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

Stu.java
    //学生所学多门课程
    public List<Course> courseList;
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

bean1.xml:
        <!--注入list集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>

    </bean>
    <!--创建多个course对象-->
    <bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="Spring5"></property>
    </bean>
    <bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="Mybatis"></property>
    </bean>

测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aB5j6QwT-1642959089952)(X:\Users\Administrator\Desktop\assets\image-20220112180723757.png)]

5、把集合注入部分提取出来

（1）在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">
</beans>

（2）使用util标签完成list集合注入提取

    <!--1.提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>六级英语</value>
        <value>雅思</value>
        <value>托福</value>
    </util:list>

    <!--2.提取list集合类型属性注入使用-->
    <bean id="book" class="com.atguigu.spring5.collectiontype.Book">
        <property name="list" ref="bookList"></property>
    </bean>

测试

    public void testCollection(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");
        context.getBean("book", Book.class);
        Book book = context.getBean("book", Book.class);
        book.test();
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TikO2s99-1642959089955)(X:\Users\Administrator\Desktop\assets\image-20220112223046695.png)]

8 Factory Bean

普通Bean是这样的：

通过id得到对象book的实例，class得到路径
<bean id="book" class="com.atguigu.spring5.collectiontype.Book">
        <property name="list" ref="bookList"></property>
</bean>

普通bean的特点就是：

在配置文件中定义bean类型就是返回类型

工厂bean的特点就是：

在配置文件中定义bean类型可以和返回类型不一样

第一步，创建MyBean类，让这个类作为工厂bean，实现接口FactoryBean

<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>

第二步，实现接口里面的方法，在实现的方法中定义的返回bean类型

public class MyBean implements FactoryBean<Course>{
    //定义返回Bean
    //我定义的是MyBean，但是我返回的是Course的course，而不是myBean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

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

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

第三步，测试：

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

9 Bean的作用域

1、在Spring里面，设置创建Bean实例是单实例还是多实例。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9jlO0nTS-1642959089956)(X:\Users\Administrator\Desktop\assets\image-20220114212924936.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NsBg3yoP-1642959089958)(X:\Users\Administrator\Desktop\assets\image-20220114212946871.png)]

如果Print出来的地址相同说明是单实例。

2、在Spring里面，默认情况下，Bean是单实例。

3、如何设置单实例或者是多实例？

（1）在Spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例。

（2）scope属性值有多个

第一个值默认值 scope=“singleton” 表示是单实例对象

第二个值 prototype 表示是多实例对象

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X8YgTnoD-1642959089959)(X:\Users\Administrator\Desktop\assets\image-20220114213926342.png)]

（3）singleton和prototype区别

第一 singleton单实例，prototype多实例

第二设置scope的值是singleton的时候，加载spring配置文件就会创建单实例对象

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

10 Bean的生命周期

生命周期就是指从对象创建到对象销毁的过程

（1）通过构造器创建bean实例（无参数构造）

public class Orders {
    private String oname;
    //无参数构造
    public Orders() {
        System.out.println("第一步，执行无参数构造创建bean实例");
    }
    public void setOname(String oname) {
        this.oname = oname;
    }
}

（2）为bean的属性设置值和对其它bean的引用（调用set方法）

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

（3）调用bean的初始化方法（需要进行配置）

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

（4）bean可以使用了（对象获取到了）

（5）当容器关闭时候，调用bean的销毁方法（需要进行配置销毁的方法）

11 自动装配

什么是自动装配？

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

演示自动装配过程

    <!--
    实现自动装配，bean标签的属性autowire，用于配置自动装配
    autowire有两个值:
        byName根据属性名称注入 注入值bean的id值和类属性名称要一样
        byType根据属性类型注入
    -->
    <bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
    </bean>

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

12 外部配置文件

方式一：直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖jar包

    <!--直接配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

方式二：引入外部属性文件配置数据库连接池

（1）创建外部属性文件，properties 格式文件，写数据库信息（jdbc.properties）放在src目录下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-niB5kH0d-1642959089961)(X:\Users\Administrator\Desktop\assets\image-20220117233306851.png)]

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=root

（2）把外部 properties 属性文件引入到 spring 配置文件中 —— 引入 context 名称空间

<?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:property-placeholder location="classpath:jdbc.properties"/>

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

2.4 IOC操作Bean管理（基于注解）

1、什么是注解

（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

2、Spring针对Bean管理中创建对象提供注解

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

（1）@Component

（2）@Service（一般用在业务服务层）

（3）@Controller（一般用在web层）

（4）@Repository（一般用在dao层）

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

第一步，引入依赖

把spring-aop-5.2.6.RELEASE.jar导入

第二步，开启组件扫描

引入context命名空间
    <!--开启组件扫描-->
    <!--1.扫描多个包的第一种写法，用逗号连接两个包的路径-->
    <!--2.第二种写法，直接写父包的路径就行！-->
    <context:component-scan base-package="com.atguigu.spring5.dao, com.atguigu.spring5.service"></context:component-scan>
    <context:component-scan base-package="com.atguigu"></context:component-scan>

第三步，创建类，在类上面添加创建对象注解

package com.atguigu.spring5.service;

import org.springframework.stereotype.Service;

//在注解里面value属性值可以不写，默认是类名称，首字母小写
@Service(value="userService") //和<bean id="userService" class=""></bean>的作用一样
public class UserService {
    public void add(){
        System.out.println("Service add..");
    }
}

第四步，测试

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

1 组件扫描配置

<?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:p="http://www.springframework.org/schema/p"
       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">
    <!--开启组件扫描-->
    <!--1.扫描多个包的第一种写法，用逗号连接两个包的路径-->
    <!--2.第二种写法，直接写父包的路径就行！-->
    <context:component-scan base-package="com.atguigu.spring5.dao, com.atguigu.spring5.service"></context:component-scan>
    <context:component-scan base-package="com.atguigu"></context:component-scan>

    <!--示例1
        use-default-filters="false"表示现在不使用默认filter，自己配置filter
        context:include-filter 用于设置扫描什么内容 例如expression=....Controller，只扫描带Controller的注解。
    -->
    <context:component-scan base-package="com.atguigu" use-default-filters="false">
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--示例2
        设置不扫描哪些内容，以下例子不扫描controller的注解。
    -->
    <context:component-scan base-package="com.atguigu">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

2 属性注入

（1）AutoWired：根据属性类型进行自动装配

第一步把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

第二步在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

//Dao实现类
@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("dao add..");
    }
}

public class UserService {
    //定义dao类型属性，不需要添加set方法，添加注入属性注解
    @Autowired
    private UserDao userDao;
    public void add(){
        System.out.println("Service add..");
        userDao.add();
    }
}

（2）Qualifier：根据名称进行注入，这个@Qualifier 注解的使用，和上面@Autowired 一起使用

//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
//根据名称进行注入（目的在于区别同一接口下有多个实现类，根据类型就无法选择，从而出错！）
@Qualifier(value = "userDaoImpl1") 
private UserDao userDao;

（3）Resource：可以根据类型注入，也可以根据名称注入（它属于javax包下的注解，不推荐使用！）

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

（4）Value：注入普通类型属性

@Value(value = "abc")
private String name

3 完全注解开发

（1）创建配置类，替代xml配置文件

package com.atguigu.spring5.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration //作为配置类，替代xml
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
}

（2）编写测试类

public class TestSpring5Demo1 {
    @Test
    public void testService(){
        //加载配置类
        ApplicationContext context
                = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }
}

三. AOP

1 AOP 基本概念

（1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能

（3）使用登录例子说明 AOP
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eAGstK4M-1642959089964)(X:\Users\Administrator\Desktop\assets\20200702135106266.png)]

2 AOP（底层原理）

a）AOP 底层使用动态代理，动态代理有两种情况：

第一种有接口情况，使用 JDK 动态代理；创建接口实现类代理对象，增强类的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vx40fPVy-1642959089965)(X:\Users\Administrator\Desktop\assets\20200702135134128.png)]

第二种没有接口情况，使用 CGLIB 动态代理；创建子类的代理对象，增强类的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dADakWvf-1642959089965)(X:\Users\Administrator\Desktop\assets\2020070213514980.png)]

3 JDK动态代理

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

调用 newProxyInstance 方法，方法有三个参数：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)

第一参数，类加载器

第二参数，增强方法所在的类，这个类实现的接口，支持多个接口

第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分
2）JDK动态代理代码编写

①创建接口，定义方法

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

②创建接口实现类，实现方法

package com.atguigu.spring5;

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

4 AOP（术语）

a）连接点：类里面哪些方法可以被增强，这些方法称为连接点

b）切入点：实际被真正增强的方法称为切入点

c）通知（增强）：实际增强的逻辑部分称为通知，且分为以下五种类型：

1）前置通知 2）后置通知 3）环绕通知 4）异常通知 5）最终通知

d）切面：把通知应用到切入点过程

5 AOP（操作）

a）Spring 框架一般都是基于 AspectJ 实现 AOP 操作，AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作

b）基于 AspectJ 实现 AOP 操作：

1）基于 xml 配置文件实现（2）基于注解方式实现（使用）

c）引入相关jar包

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U4H6Huh2-1642959089968)(X:\Users\Administrator\Desktop\assets\image-20220121102112144.png)]

d）切入点表达式，如下：

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强 
（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )
（3）例子如下：
    例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强
		execution(* com.atguigu.dao.BookDao.add(..))
 	例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强
		execution(* com.atguigu.dao.BookDao.* (..))
    例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强
		execution(* com.atguigu.dao.*.* (..))

1 AspectJ注解

1、创建类，在类里面定义方法

public class User {
    public void add(){
        System.out.println("user add...");
    }
}

2、创建增强类（编写增强逻辑）

//增强的类
public class UserProxy{
    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

3、进行通知的配置

（1）在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="com.atguigu.spring5.aopanno"></context:component-scan>
</beans>

（2）使用注解创建User和UserProxy对象

@Component
public class UserProxy{
    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

@Component
public class User {
    public void add(){
        System.out.println("user add...");
    }
}

（3）在增强类上面添加注释@Aspect

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

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy{
    //前置通知
    public void before(){
        System.out.println("before...");
    }
}

（4）配置不同类型的通知

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

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy{
    //before注解表示作为前置通知
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    //前置通知
    public void before(){
        System.out.println("before...");
    }

    @AfterReturning(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    //后置通知(返回通知) 有异常不通知
    public void afterReturning(){
        System.out.println("afterReturning...");
    }
    
    @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    //最终通知 有没有异常都会执行
    public void after(){
        System.out.println("after...");
    }

    @AfterThrowing(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    //异常通知 发生了异常才会通知
    public void afterThrowing(){
        System.out.println("afterThrowing...");
    }

    @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    //环绕
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前...");
        //被增强的方法执行
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后...");
    }
}

测试

public class TestAop {
    @Test
    public void testAopAnno(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
}

（5）相同的切入点抽取

    //相同切入点抽取
    @Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void pointdemo(){

    }

    //before注解表示作为前置通知(value值直接改成切入点抽取的那个方法名)
    @Before(value = "pointdemo()")
    //前置通知
    public void before(){
        System.out.println("before...");
    }

（6）有多个增强类对同一个方法进行增强，设置增强类优先级 @Order(值)

@Component
@Aspect
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
    public void before(){
        System.out.println("person before...");
    }
}

2 AspectJ 配置文件

一般采用注解，不用xml配置，所以了解一下就行

<!--1、创建两个类，增强类和被增强类，创建方法（同上一样）-->
<!--2、在 spring 配置文件中创建两个类对象-->
<!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>
<!--3、在 spring 配置文件中配置切入点-->
<!--配置 aop 增强-->
<aop:config>
 <!--切入点-->
 <aop:pointcut id="p" expression="execution(* com.atguigu.spring5.aopxml.Book.buy(..))"/>
 <!--配置切面-->
 <aop:aspect ref="bookProxy">
 <!--增强作用在具体的方法上-->
 <aop:before method="before" pointcut-ref="p"/>
 </aop:aspect>
</aop:config>

四. JDBCTemplate

1 JdbcTemplate概念及使用

a）Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

b）引入相关 jar 包

c）在 spring 配置文件配置[数据库连接池]

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
 destroy-method="close">
 <property name="url" value="jdbc:mysql:///test" />
 <property name="username" value="root" />
 <property name="password" value="root" />
 <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

d）配置 JdbcTemplate 对象，注入 DataSource

<!-- JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
 <!--注入 dataSource-->
 <property name="dataSource" ref="dataSource"></property><!--set方式注入-->
</bean>

e）创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象

<!-- 组件扫描 -->
<context:component-scan base-package="com.atguigu"></context:component-scan>

@Service
public class BookService {
 //注入 dao
 @Autowired
 private BookDao bookDao;
}

@Repository
public class BookDaoImpl implements BookDao {
 //注入 JdbcTemplate
 @Autowired
 private JdbcTemplate jdbcTemplate;
}

2 JdbcTemplate 操作数据库（添加）

a）对应数据库创建实体类

b）创建service和dao

（1）在 dao 进行数据库添加操作

（2）调用 JdbcTemplate 对象里面 update 方法实现添加操作

@Repository
public class BookDaoImpl implements BookDao {
 //注入 JdbcTemplate
 @Autowired
 private JdbcTemplate jdbcTemplate;
 //添加的方法
 @Override
 public void add(Book book) {
 //1 创建 sql 语句
 String sql = "insert into t_book values(?,?,?)";
 //2 调用方法实现
 Object[] args = {book.getUserId(), book.getUsername(),book.getUstatus()};
 int update = jdbcTemplate.update(sql,args);
 System.out.println(update);
 }
}

3 JdbcTemplate 操作数据库（修改和删除）

//1、修改
@Override
public void updateBook(Book book) {
 String sql = "update t_book set username=?,ustatus=? where user_id=?";
 Object[] args = {book.getUsername(), book.getUstatus(),book.getUserId()};
 int update = jdbcTemplate.update(sql, args);
 System.out.println(update);
}
//2、删除
@Override
public void delete(String id) {
 String sql = "delete from t_book where user_id=?";
 int update = jdbcTemplate.update(sql, id);
 System.out.println(update);
}
//使用JdbcTemplate 模板所实现的 “增删改” 都是调用了同一个 “update” 方法

4 JdbcTemplate 操作数据库（查询返回某个值）

//查询表记录数
@Override
public int selectCount() {
 String sql = "select count(*) from t_book";
//queryForObject方法中：第一个参数代表--sql语句；第二个参数代表--返回类型class  
 Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
 return count;
}

5 JdbcTemplate 操作数据库（查询返回对象）

//查询返回对象
@Override
public Book findBookInfo(String id) {
 String sql = "select * from t_book where user_id=?";
 //调用方法
/*
	queryForObject方法中：
		第一个参数：sql语句
		第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面 实现类 完成数据封装
		第三个参数：sql 语句值
*/
 Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
 return book;
}

6 JdbcTemplate 操作数据库（查询返回集合）

//所用场景：查询图书列表分页、、
//查询返回集合
@Override
public List<Book> findAllBook() {
 String sql = "select * from t_book";
 //调用方法
 List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
 return bookList;
}

7 JdbcTemplate 操作数据库（批量操作）

//批量添加
@Override
public void batchAddBook(List<Object[]> batchArgs) {
 String sql = "insert into t_book values(?,?,?)";
//batchUpdate方法 第一个参数：sql语句		第二个参数：List集合，添加多条记录数据
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}

//批量添加测试
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3","java","a"};
Object[] o2 = {"4","c++","b"};
Object[] o3 = {"5","MySQL","c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用批量添加
bookService.batchAdd(batchArgs);

8 JdbcTemplate 实现批量修改操作

//批量修改(同批量添加一样，调用同一个方法)
@Override
public void batchUpdateBook(List<Object[]> batchArgs) {
 String sql = "update t_book set username=?,ustatus=? where user_id=?";
 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
 System.out.println(Arrays.toString(ints));
}