Spring5复习

学过一段时间回来全面复习一波并做一个详细记录（看的是尚硅谷的spring5）
百度可知

Spring框架：
1.是一个开放源代码的JavaEE应用程序框架，是针对bean的生命周期进行管理的轻量级容器。
2.可以解决企业应用开发的复杂性
3.有两个核心IOC和Aop
（1）IOC：控制反转，把创建对象的过程交给Spring进行管理
（2）Aop：面向切面，不修改源代码的情况下进行功能增强
框架的相关特点：
（1）方便解耦，简化开发
（2）Aop编程支持
（3）方便程序的测试
（4）方便集成各种优秀的框架
（5）方便进行事务操作
（6）降低API的使用难度（比如封装JDBC）

正式开始码！

刚开始先添加相关jar包，我第一次用的是jar包，这次复习就试试maven先加入以下相关依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.3</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
 </dependencies>

1.入门案例

先把我的整个目录结构放在这，因为我的是maven工程所以是这样的，如果你是普通的Java工程，可以把配置文件和测试类都放在src目录下

先创建一个User实体类

public class User {

    public void add(){
        System.out.println("来自User的add------>");
    }
}

一般我们想使用User和User中的add的方法就是new一个对象然后调用，既然引入的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">

    <!--配置User类对象的创建-->
    <!--id就相当于你给对象起的一个别名，class是这个类的全类名路径-->
    <bean id="user" class="com.yourhxy.spring.User"></bean>
</beans>

配置文件创建完后，我们进行测试，创建一个测试类，注意配置文件名别写错了，不然找半天不知道错在哪建议复制粘贴

public class TestSpring {

    @Test
    public void testAdd(){
        //1.加载Spring配置文件  注意配置文件的名字别写错了
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring1.xml");
        //2.获取配置创建的对象   参数就是配置文件中配置的的id属性
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();
    }
}

之后我们进行运行，测试成功，结果如下：

2.IOC容器

IOC：控制反转，是面向对象编程中的一种设计原则，可以用来减少计算机代码之间的耦合度，通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象引用传递给它，也可以说被注入到对象。把对象创建和对象之间的调用过程，都交给Spring进行管理

IOC底层原理：
（1）xml解析，工厂模式，反射

IOC过程：
使用场景：一个UserService类和UserDao类，再加上一个工厂类，Service类要调用Dao类，直接调用耦合度太高，工厂类中直接创建Dao对象可以降低耦合但效果不明显。
（1）第一步xml配置文件进行配置要创建的对象
（2）第二步创建工厂类，在工厂类中使用反射创建Dao类的对象，首先获取这个类的全类名路径也就是在xml配置文件中声明的class属性，再进行反射进而强转从而获取这个Dao类，在Service中调用工厂类生成Dao类的对象进而去使用，达到解耦合的作用（如果Dao类要发生路径等等的改变，工厂类中的反射过程不需要改变）

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

2.Spring提供IOC容器实现两种方式：（两个接口）：
（1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员的使用。
使用BeanFactory加载配置文件时不会创建对象当获取对象或使用对象时才会创建对象
（2）ApplicationContext：BeanFactory接口的子接口，提供更强大的功能一般由开发人员使用。
使用ApplicationContext加载配置文件就会创建对象FileSystemXmlApplicationContext：指明的路径是你系统的盘符里详细路径的配置文件
ClassPathXmlApplicationContext：指明的是类路径，src目录下的配置文件

1.IOC操作Bean管理

Bean管理：
两个操作：
（1）Spring创建对象
（2）Spring注入属性
两种方式：
（1）基于xml配置文件方式实现
（2）基于注解方式实现

IOC操作Bean管理（基于xml方式）
1.基于xml方式创建对象
（1）就是在配置文件中添加对象的相关配置上面已截图
（2）bean标签中的id，class属性在上面已经进行介绍了
（3）创建对象的时候默认是调用类的无参构造方法

2.基于xml方式注入属性
（1）DI：依赖注入
1.第一种注入方式就是使用set方法注入
先创建一个Book实体类

public class Book {

    private String bname;
    private String bauthor;

    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

    public void testDemo(){
        System.out.println(bname+"::"+bauthor);
    }
}

在配置文件中进行配置创建对象注入属性（可以在上面那个配置文件中或者新建一个配置文件加入以下内容）

<bean id="book" class="com.yourhxy.spring.Book">
        <!--使用property标签完成属性的注入
        标签中的name即属性名  value即属性名-->
        <property name="bname" value="易筋经"/>
        <property name="bauthor" value="达摩"/>
</bean>

然后进行测试

 @Test
 public void testBook1(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring1.xml");
        Book book = context.getBean("book", Book.class);
        System.out.println(book);
        book.testDemo();
    }

测试结果如下
测试成功

2.第二种使用类的有参构造进行注入
先创建一个类并加入有参构造方法

public class Order {

    private String oname;
    private String address;

    public Order(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
    
    public void testDemo(){
        System.out.println(oname+"::"+address);
    }
}

在配置文件中进行配置,使用constructor-arg标签，name是属性名 value是属性值，在这里name属性可以替换使用index，index=“0”，就表示有参构造第一个参数，以此类推在此就不做示例展示了

<bean id="order" class="com.yourhxy.spring.Order">
        <constructor-arg name="address" value="北京"/>
        <constructor-arg name="oname" value="abc"/>
</bean>

接下来进行测试

@Test
public void testOrder(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring1.xml");
        Order order = context.getBean("order", Order.class);
        System.out.println(order);
        order.testDemo();
    }

测试结果如下
测试成功

3.还有一种p名称空间注入（了解即可）

先在配置文件上添加p名称空间
就是加上这一行
xmlns:p=“http://www.springframework.org/schema/p”

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

随便创建一个实体类拿来测试

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

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

    public void setAge(Integer age) {
        this.age = age;
    }
    
    public void testDemo(){
        System.out.println(name+"::"+age);
    }
}

在配置文件中这样使用

<bean id="person" class="com.yourhxy.spring.Person" 
          p:name="汤姆" p:age="18"/>

进行测试

@Test
public void testPerson(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring1.xml");
        Person person = context.getBean("person", Person.class);
        System.out.println(person);
        person.testDemo();
    }

测试成功

4.注入属性为特殊空值或者特殊符号时

（1）注入属性为空值时
为了避免代码不清晰来回注释，索性每个示例都创建了一个实体类

public class Car {
    //车的名字
    private String name;
    //车的使用年龄
    private Integer age;
    //车的车牌号
    private String number;

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

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

    public void setNumber(String number) {
        this.number = number;
    }

    public void testDemo(){
        System.out.println(name+"::"+age+"::"+number);
    }
}

在配置文件中进行配置并将属性注入null即空值

<bean id="car" class="com.yourhxy.spring.Car">
        <property name="name" value="奔驰"/>
        <property name="age" value="5"/>
        <property name="number">
            <null></null>
        </property>
</bean>

上面的测试类贴了那么多次想必都很熟悉了就直接贴个代码和结果图咯
（2）注入属性为特殊符号时
实体类

public class City {
    private String name;

    public void setName(String name) {
        this.name = name;
    }
    
    public void testDemo(){
        System.out.println(name);
    }
}

此时假设要注入的属性值为“<<南京>>”，配置文件中操作如下

<!--属性中包含特殊符号
    方法1.把<>进行转义
    方法2.把带特殊符号内容写到CDATA中-->
    <bean id="city" class="com.yourhxy.spring.City">
        <property name="name">
            <value><![CDATA[<<南京>>]]></value>
        </property>
    </bean>

此时再进行测试
测试成功

5.注入属性为外部bean时
使用场景：在service中调用dao
首先创建dao接口和实现类以及service类并要在service中添加dao类并调用其方法

public interface UserDao {

    public void update();
}

public class UserDaoImpl implements UserDao{

    public void update() {
        System.out.println("dao中的update.....");
    }
}

public class UserService {

    //创建UserDao类型的属性
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add.......");
        userDao.update();
    }
}

在配置文件中进行配置，注意这个时候注入的属性是外部bean要用ref

<?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="userService" class="com.yourhxy.spring.service.UserService">
        <!--注入外部userDao对象
        name：属性名
        ref:创建userDao对象的bean标签的id值-->
        <property name="userDao" ref="userDaoImpl"/>
    </bean>
    <bean id="userDaoImpl" class="com.yourhxy.spring.dao.UserDaoImpl"/>
</beans>

进行测试
测试成功！

5.注入属性为内部bean和级联赋值
使用场景：部门和员工，一对多的关系进行示例展示

先创建员工类和部门类

//部门类
public class Dept {

    private String name;

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

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

//员工类
public class Emp {

    private String ename;
    private String gender;
    //员工属于某一个部门使用对象形式表示
    private Dept dept;
    
	public Dept getDept() {
        return dept;
    }
    
    public void setEname(String ename) {
        this.ename = ename;
    }

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

    public void setDept(Dept dept) {
        this.dept = dept;
    }

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

在配置文件中进行配置,此时用的是内嵌bean对象给dept属性进行注入，级联赋值一种方式就是使用上面的ref进行外部bean引用，另一种方式直接对外部bean的属性进行赋值，但是此时必须要有外部bean的get方法

普通的注入外部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-->
    <bean id="emp" class="com.yourhxy.spring.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Tom"/>
        <property name="gender" value="男"/>
        <property name="dept">
            <bean id="dept" class="com.yourhxy.spring.bean.Dept">
                <property name="name" value="财务部"/>
            </bean>
        </property>
    </bean>
</beans>

第一种级联赋值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="emp" class="com.yourhxy.spring.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="Tom"/>
        <property name="gender" value="男"/>
        <property name="dept" ref="dept"/>
    </bean>
    <bean id="dept" class="com.yourhxy.spring.bean.Dept">
        <property name="name" value="财务部"/>
    </bean>
</beans>

第二种级联赋值（dept.name进行直接赋值但是需要Emp中的Dept的get方法）

<?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="com.yourhxy.spring.bean.Emp">
            <!--设置两个普通属性-->
            <property name="ename" value="Tom"/>
            <property name="gender" value="男"/>
            <property name="dept.name" value="技术部"/>
        </bean>
</beans>

接下来进行测试
测试成功！！

6.注入属性为数组，List，Map和Set时

先创建一个实体类，属性分别为上面的三种类型，并生成相关的set方法

public class Stu {
    //1.数组类型属性
    private String[] courses;
    //2.List集合类型属性
    private List<String> list;
    //3.Map集合属性
    private Map<String,String> map;
    //4.Set集合类型的属性
    private Set<String> set;

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

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

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

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

    @Override
    public String toString() {
        return "Stu{" +
                "courses=" + Arrays.toString(courses) +
                ", list=" + list +
                ", map=" + map +
                ", set=" + set +
                '}';
    }
}

在配置文件中进行相关的配置

<?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="com.yourhxy.spring.Stu">
        <!--数组类型属性的注入-->
        <property name="courses">
            <array>
                <value>语文</value>
                <value>数学</value>
                <value>英语</value>
            </array>
        </property>
        <!--List类型的属性注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
            </list>
        </property>
        <!--Map类型的属性注入-->
        <property name="map">
            <map>
                <entry key="语文" value="100"/>
                <entry key="数学" value="100"/>
                <entry key="英语" value="100"/>
            </map>
        </property>
        <!--Set属性注入-->
        <property name="set">
            <set>
                <value>MySQL</value>
                <value>Redis</value>
            </set>
        </property>
    </bean>
</beans>

进行测试
测试成功！！

7.注入属性为List集合类型，且集合里是对象
先创建一个Course类

//课程类
public class Course {
    //课程名称
    private String cname;

    public void setCname(String cname) {
        this.cname = cname;
    }

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

在上面的Stu类中添加这个属性并添加set方法，顺便改一下toString()方法

	//5.加入课程属性
    private List<Course> courseList;
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

去配置文件中配置，先配置外部的多个Course对象

	<!--创建多个course对象-->
    <bean id="course1" class="com.yourhxy.spring.Course">
        <property name="cname" value="Spring"/>
    </bean>
    <bean id="course2" class="com.yourhxy.spring.Course">
        <property name="cname" value="SpringMVC"/>
    </bean>
    <bean id="course3" class="com.yourhxy.spring.Course">
        <property name="cname" value="Mybatis"/>
    </bean>

在Stu的配置中添加下列内容

		<!--注入的是List集合类型，值是对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
                <ref bean="course3"></ref>
            </list>
        </property>

进行测试
测试成功！！

8.把注入的属性提取出来，可以多次使用进行调用

先创建一个Book类

public class Book {
    private List<String> list;

    public List<String> getList() {
        return list;
    }

    @Override
    public String toString() {
        return "Book{" +
                "list=" + list +
                '}';
    }
}

在配置文件中进行修改，引入名称空间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">

    <!--把注入的list集合的元素进行提取-->
    <util:list id="bookList">
        <value>钢铁是咋炼成的</value>
        <value>三国</value>
        <value>水浒</value>
    </util:list>
    <!--配置Book对象-->
    <bean id="book" class="com.yourhxy.spring.Book">
        <property name="list" ref="bookList"/>
    </bean>
</beans>

进行测试
测试成功！！

3.Spring有两种bean：
一种普通的bean另外一种是bean(FactoryBean)
普通bean：在配置文件中定义bean类型就是返回类型
工厂bean：在配置文件定义bean类型可以和返回类型不一样

先创建类，让这个类作为工厂bean，实现接口FactoryBean
实现接口中的方法在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {

    //定义返回bean
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

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

配置文件就是正常配置但是返回的类型不是MyBean

<?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="com.yourhxy.spring.factorybean.MyBean"></bean>
</beans>

测试

4.bean的作用域
在Spring中设置bean的实例是单实例还是多实例（默认是单实例）
以Book为例，先把之前那个Book类重写的toString()方法删掉，得到的结果如下，单实例无疑

如何配置单实例还是多实例？在配置文件中这样配置首先默认就是单实例或者在配置文件中设置scope=“singleton”

<!--配置Book对象-->
    <bean id="book" class="com.yourhxy.spring.Book" scope="singleton">
        <property name="list" ref="bookList"/>
    </bean>

测试

依然是单实例，接着配置scope="prototype"并进行测试
果然此时是多实例，scope="prototype"表示设置多实例，
另外当scope=“singleton”，加载 spring 配置文件时候就会创建单实例对象，当scope="prototype"不是在加载 spring 配置文件时候创建对象，而是在调用getBean 方法时候创建多实例对象

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

操作步骤：先创建一个实体类

public class Orders {

    private String oname;

    public Orders() {
        //为了显示明显在此进行输出
        System.out.println("第一步  执行无参数构造创建bean实例");
    }

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

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

    //创建执行销毁的方法
    public void destoryMethod(){
        System.out.println("第五步  调用销毁方法");
    }
}

接着在配置文件中进行配置，同时要配置初始化方法和销毁方法

<?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="orders" class="com.yourhxy.spring.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
        <property name="oname" value="手机"/>
    </bean>
</beans>

然后进行测试
加上bean后置处理器，此时bean的生命周期有七步
（1）通过构造器创建bean实例（无参数构造）
（2）为bean的属性设置和对其他bean引用（调用set方法）
（3）把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
（4）调用bean的初始化方法（需要进行配置初始化的方法）
（5）把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
（6）bean可以使用了（对象已经获取到了）
（7）当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）

创建一个类实现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 null;
    }
}

在配置文件中进行相关配置也就是在原有的配置文件中加入以下内容，可能你感觉这样配置和你上面的类配置一点关系都没有，其实是配置一个后置处理器会对一个配置文件中所有的bean配置生效，也就是让一个配置文件中的所有bean都添加后置处理器，可以自己进行测试

 <bean id="myBeanPost" class="com.yourhxy.spring.bean.MyBeanPost"></bean>

测试类不变，进行测试结果如下

6.自动装配
所谓自动装配就是根据指定的装配规则，Spring自动将匹配的属性值进行注入
实现自动装配使用的是bean标签中的autowire属性：
（1）ByName根据属性名称注入，注入值bean的配置的bean标签中的id值和类属性名称一样
（2）ByType根据类型注入，但是如果在配置文件中有多个和要注入的bean类型相同的bean就会报错，因为只是根据类型，并不知道要注入哪一个

先创建两个简易的Emp和Dept实体类，在配置文件中进行配置

public class Emp {

    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void testDemo(){
        System.out.println("Emp{dept="+dept+"}");
    }
}

public class Dept {

    private String name;

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

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

①根据属性名称进行自动注入的配置文件

<?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="com.yourhxy.spring.Emp" autowire="byName"></bean>
    <bean id="dept" class="com.yourhxy.spring.Dept">
        <property name="name" value="财务部"/>
    </bean>
</beans>

进行测试
②根据属性类型进行自动注入的配置文件，这个时候在配置文件中只能有一个dept类型的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="emp" class="com.yourhxy.spring.Emp" autowire="byName"></bean>-->
    <bean id="emp" class="com.yourhxy.spring.Emp" autowire="byType"></bean>
    <bean id="dept" class="com.yourhxy.spring.Dept">
        <property name="name" value="财务部"/>
    </bean>
</beans>

进行测试
7.引入外部属性文件进行配置
使用场景：当我们配置数据库连接池时，url，username等等都是必需的，但如果用一次们就临时配置一次，那如果数据库改变，那修改起来太过麻烦，于是我们把这些需要的条件都保存在外部的一个属性文件中再进行读取配置，这样即使数据库修改我们只需要改外部的配置文件即可

注：先添加相关jar包或者依赖避免代码没写错半天连不上

<dependency>        
	<groupId>com.alibaba</groupId>
   	<artifactId>druid</artifactId>
    <version>1.2.4</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.19</version>
</dependency>

创建外部属性文件，.properties的文件，在这个文件中写上数据库连接信息

prop.url=xxxxxx
prop.username=xxxxxx
prop.password=xxxxxx
prop.driverClassName=com.mysql.cj.jdbc.Driver

在配置文件中引入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="jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClassName}"/>
        <property name="url" value="${prop.url}"/>
        <property name="username" value="${prop.username}"/>
        <property name="password" value="${prop.password}"/>
    </bean>
</beans>

进行测试
8.基于注解方式进行创建对象和注入属性
使用注解方式主要是为了简化xml配置

Spring针对Bean管理中创建对象提供的注解
①@Component
②@Service
③@Controller
④@Repository
这四个注解的功能是一样的都可以用来创建bean实例，但是我们一般习惯将他们分类用在不同层中，比如我们更习惯将@Service用在Service层中

准备考研了，考完研再更！！