入门案例

一、下载spring5
spring5下载地址。本文使用Spring稳定版本5.2.6


二、打开idea工具，创建普通Java工程，一路next

三、导入Spring5相关jar包

我们可以看到，spring的核心容器有四个，所以我们spring5的解压文件的Libs中找到这四个相关文件及logging文件，将这五个文件复制到spring5-test\lib文件夹下

并将这五个包导入到项目中：Project Structure-modules-+-jars


点apply-》ok即可
四、创建普通类（new-java class-User），在这个类创建普通方法

public class User {
    public void add() {
        System.out.println("add......");
    }
}
1
2
3
4
5

以前通过new就可以创建这个类的对象，但是现在我们想通过spring5实现创建对象，可以通过注解、配置文件的方式实现，我们现在先来感受一下配置文件的实现方法，进行下面的步骤：
五、创建Spring配置文件，在配置文件配置创建的对象：Spring配置文件使用xml格式，所以新建src/bean1.xml，在里面进行创建User类对象的相关配置，这里面有个bean标签，专门用来进行创建对象的相关配置，bean标签的两个属性：

1. id：指定bean标签的id
2. class：指定类的全路径（包+类名）

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

六、编写测试代码
新建src/com/atguigu/spring5/testdemo/TestSpring5.java，代码如下：

public class TestSpring5 {
    @Test
    public void testAdd() {
        //1 加载spring配置文件 因为bean1.xml在src文件夹下，所以使用ClassPathXmlApplicationContext(文件名)来加载
		//如果bean1.xml不在src文件夹下，使用ClassPathXmlApplicationContext(路径/文件名)来加载
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        //2 获取配置创建的对象：context.getBean(bean标签的id值, 类名.class);
		//等号左边的user就是我们通过spring创建的User类的对象
        User user = context.getBean("user", User.class);

        System.out.println(user);
        user.add();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

IOC

一、什么是 IOC

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

二、IOC底层原理：xml 解析、工厂模式、反射
示例：假如我想在service类中调用dao类的方法，以前的方法是在service类中创建dao对象，然后直接通过对象调用方法，这样耦合度太高，现在我们使用IOC通过xml解析和反射的方式实现：

1. 在xml配置文件中配置创建的对象：<bean id="user" class="com.atguigu.spring5.User"></bean>
2. 有service类和dao类，创建工厂类：

class UserFactory{
	public static UserDao getDao() {
		String classValue = class属性值; // 1. 进行xml解析，获得bean标签的class属性值：com.atguigu.spring5.User
		// 2. 通过反射创建对象:Class.forName(全路径或包路径+类名)
		Class clazz = Class.forName(classValue);
		return (UserDao)clazz.newInstance();
	}
}
1
2
3
4
5
6
7
8

反射：得到类的字节码文件
三、IOC接口

1. IOC思想基于IOC容器完成，容器底层就是对象工厂，在这个工厂里面读取配置文件，通过反射创建对象。
2. Spring提供IOC容器实现两种方式，即两个接口：
   （1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用

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

使用：在src/com/atguigu/spring5/testdemo/TestSpring5.java中使用BeanFactory加载spring配置文件:BeanFactory context = new ClassPathXmlApplicationContext("bean1.xml");
（2）ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

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

3. ApplicationContext接口有实现类，他们都在src/com/atguigu/spring5/testdemo/TestSpring5.java中加载spring配置文件时使用
   
   （1）ApplicationContext context = new FileSystemXmlApplicationContext(配置文件在系统盘里的路径);
   （2）ApplicationContext context = new ClassPathXmlApplicationContext(src下的类路径);

IOC操作Bean管理

一、Bean管理指的是两个操作：

1. 使用Spring创建对象，如入门案例
2. 使用Spirng注入属性：使用spring给类中的属性创建setter

二、Bean管理操作有两种方式：

1. 基于xml配置文件方式实现
2. 基于注解方式实现

基于xml配置文件方式实现Bean管理操作

基于xml方式创建对象

一、在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
二、在bean标签有很多属性，介绍常用的属性

1. id属性：唯一标识
2. class属性：类全路径（包类路径）

三、创建对象时候，默认是执行无参数构造方法完成对象创建，如果你在类中创建了有参构造方法而没有写无参构造方法，相当于此时类中没有无参构造方法，会报错

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

基于xml方式注入属性

一、DI是IOC的具体实现，他表示依赖注入，就是注入属性，但他需要在创建对象的基础上完成属性注入，即先创建对象再注入属性
二、第一种注入方式：使用set方法进行注入

1. 创建类，定义属性和对应的set方法

public class Book {
	//创建属性
	private String bname;
 	private String bauthor;
 	//创建属性对应的 set 方法
	public void setBname(String bname) {
		this.bname = bname;
 	 }
	 public void setBauthor(String bauthor) {
 		this.bauthor = bauthor;
 	}
}
1
2
3
4
5
6
7
8
9
10
11
12

2. 在spring配置文件bean1.xml配置对象创建，配置属性注入

<!--配置Book对象创建-->
<bean id="book" class="com.atguigu.spring5.Book">
<!--在bean标签中使用property标签完成属性注入
	name：类里面属性名称
	value：向属性注入的值
-->
	<property name="bname" value="易筋经"></property>
	<property name="bauthor" value="达摩老祖"></property>
</bean>
1
2
3
4
5
6
7
8
9

优化：前面我们在spring配置文件bean1.xml中进行属性注入时，你有多少个属性就要使用property属性写多少行，很繁琐：

<property name="bname" value="易筋经"></property>
<property name="bauthor" value="达摩老祖"></property>
1
2

我们可以使用p名称空间注入属性来简化

1. 添加p名称空间在配置文件中
   
2. 进行属性注入，在bean标签里面进行操作，直接在bean标签中简化写：p.属性名=“属性值”，如下：

<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏"></bean>-->
1

上述代码等同于：

<bean id="book" class="com.atguigu.spring5.Book">
	<property name="bname" value="易筋经"></property>
	<property name="bauthor" value="达摩老祖"></property>
</bean>
1
2
3
4

优化结束

3. 在TestSpring5.java中进行测试：

public class TestSpring5 {
    @Test
    public void testBook1() {
        //1 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        //2 获取配置创建的对象
        Book book = context.getBean("book", Book.class);

        System.out.println(book);
        book.testDemo();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

1. 创建类，定义属性，创建属性对应有参数构造方法

public class Orders {
    //属性
    private String oname;
    private String address;
    //有参数构造
    public Orders(String oname,String address) {
        this.oname = oname;
        this.address = address;
    }

    public void ordersTest() {
        System.out.println(oname+"::"+address);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

（2）在spring配置文件bean1.xml中的bean标签中使用constructor-arg标签进行配置，其中name属性指定你想注入类的哪个属性，value属性指定你给属性注入的值

<bean id="orders" class="com.atguigu.spring5.Orders">
	<constructor-arg name="oname" value="电脑"></constructor-arg>
	<constructor-arg name="address" value="China"></constructor-arg>
</bean>
1
2
3
4

（3）在TestSpring5.java中进行测试：

public class TestSpring5 {
    @Test
    public void testOrders() {
        //1 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");

        //2 获取配置创建的对象
        Orders orders = context.getBean("orders", Orders.class);

        System.out.println(orders);
        orders.ordersTest();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

基于xml方式注入其他类型属性

注入字面量

一、null值：给Book类的address属性设为null值，bean1.xml中的bean标签中的property标签中不再配置value属性，而是在property标签中直接写个<null/>

<bean id="book" class="com.atguigu.spring5.Book">
	<!--null值：向属性中设置null值-->
    <property name="address">
		<null/>
	</property>
</bean>
1
2
3
4
5
6

二、属性值包含特殊符号：

1. 在bean1.xml中的bean标签中的property标签中配置value属性时，将特殊字符进行转义，如把<、>分别转义为<和>

<bean id="book" class="com.atguigu.spring5.Book">
	<property name="address" value="&lt;&lt;南京&gt;&gt;"></property>
</bean>
1
2
3

2. 在bean1.xml中的bean标签中的property标签中不再配置value属性，而是写value标签，并把带特殊符号内容写到CDATA中，即<![CDATA[属性值]]，将CDATA作为value标签内容，如下：

<bean id="book" class="com.atguigu.spring5.Book">
	<property name="address">
    	<value><![CDATA[<<南京>>]]></value>
    </property>
</bean>
1
2
3
4
5

注入属性

注入属性有两种方式：内部bean、外部bean

外部bean

一、操作中应该有三层：web层调用service层，service层调用DAO层，通过service层调用DAO层就被称为引入外部bean
二、步骤：

1. 创建两个类service类和dao类：
   新建src/com/atguigu/spring5/service/UserService.java，代码如下：

public class UserService {
    public void add() {
        System.out.println("service add...............");
    }
}
1
2
3
4
5

新建src/com/atguigu/spring5/dao文件夹，该文件夹下新建UserDao接口UserDao.java代码如下：

public interface UserDao {
    public void update();
}
1
2
3

及其实现类UserDaoImpl.java，代码如下：

public class UserDaoImpl implements UserDao {
    @Override
    public void update() {
        System.out.println("dao update...........");
    }
}
1
2
3
4
5
6

2. 在service调用dao里面的方法
   方法一：普通方法：在service中创建dao对象，通过对象调用方法，UserService.java代码如下：

public class UserService {
    public void add() {
        System.out.println("service add...............");
        UserDso userDao = new UserDaoImpl();
        userDao.update();
    }
}
1
2
3
4
5
6
7

方法二：使用spring实现：在spring配置文件中进行配置
思路：

1. 在配置文件中创建service和dao的对象
2. 将dao注入service中，可以使用set注入、有参构造函数注入

实现：

1. 在UserService中创建UserDao类型属性，因为后面会在在service中注入dao，所以在service中生成dao的set方法：

public class UserService {
    //创建UserDao类型属性，生成set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("service add...............");
        userDao.update();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

2. 新建配置文件src/bean2.xml，在其中创建service和dao的对象

<bean id="userService" class="com.atguigu.spring5.service.UserService"></bean>
<!--创建UserDao对象时注意使用UserDaoImpl，因为UserDao是一个接口，接口不能new对象，所以要找他的实现类来new对象-->
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>
1
2
3

3. 在service中注入dao：在userService的bean标签中使用property标签实现注入

<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>
1
2
3
4
5
6
7
8

4. 测试：新建src/com/atguigu/spring5/testdemo/TestBean.java文件，代码如下：

public class TestBean {
    @Test
    public void testBean1() {
        //1 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");

        //2 获取配置创建的对象
        UserService userService = context.getBean("userService", UserService.class);

        userService.add();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

内部bean

一、数据库表与表之间有一对一、一对多的关系，比如部门和员工就是一对多关系，一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多
二、现在我们要在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
三、内部bean：在一个对象中可以嵌套定义另一个对象
四、实现：

1. 新建src/com/atguigu/spring5/bean包，在其中创建Dept.java，代码如下：

//部门类
public class Dept {
    private String dname;
    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

及Emp.java，代码如下：

//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属于某一个部门，使用对象形式表示
    private Dept dept;

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

    public void add() {
        System.out.println(ename+"::"+gender+"::"+dept);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. 新建src/bean3.xml，在其中进行内部bean配置，直接在emp的bean标签中的property标签中创建dept对象：

<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>
1
2
3
4
5
6
7
8
9
10
11

3. 测试：TestBean.java代码如下：

public class TestBean {
    @Test
    public void testBean1() {
        //1 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean3.xml");

        //2 获取配置创建的对象
        Emp emp = context.getBean("emp", Emp.class);

        emp.add();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

级联赋值

一、级联赋值：可以同时向有关联的类的属性中设值，可以说是内部bean、外部bean的另一种写法。
二、本例实现我在给emp赋值时，给dept也赋值
三、第一种写法：

<bean id="emp" class="com.atguigu.spring5.bean.Emp">
	<!--设置两个普通属性-->
 	<property name="ename" value="lucy"></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>
1
2
3
4
5
6
7
8
9
10

四、第二种写法：

<bean id="emp" class="com.atguigu.spring5.bean.Emp">
	<!--设置两个普通属性-->
	<property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>
    <!--级联赋值-->
   	<property name="dept" ref="dept"></property>
    <property name="dept.dname" value="技术部"></property>
</bean>
1
2
3
4
5
6
7
8

因为我们这里涉及给emp.dept.dname赋值的操作，所以需要为Emp的dept属性生成setter，dept属性其实就是Dept类，在Emp.java中新增代码：

public class Emp {
    //生成dept的get方法
    public Dept getDept() {
        return dept;
    }
1
2
3
4
5

测试，TestBean.java代码如下：

public class TestBean {
    @Test
    public void testBean2() {
        //1 加载spring配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");

        //2 获取配置创建的对象
        Emp emp = context.getBean("emp", Emp.class);

        emp.add();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

xml注入集合属性

一、注入数组类型属性、注入List集合类型属性、注入Map集合类型属性

1. 新建一个项目spring5_demo2，并新建src/com/atguigu/spring5/collectiontype/Stu.java文件，在其中创建类，定义数组、list、map、set 类型属性，生成对应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 setSets(Set<String> sets) {
        this.sets = 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 test() {
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2. 在spring配置文件bean1.xml中使用各种标签进行配置：

<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
 	<!--使用array标签或list标签进行数组类型属性注入-->
    <property name="courses">
    	<array>
    		<value>java课程</value>
        	<value>数据库课程</value>
		</array>
	</property>
    <!--使用list标签进行list类型属性注入-->
    <property name="list">
    	<list>
        	<value>张三</value>
            <value>小三</value>
        </list>
	</property>
	<!--使用map标签进行map类型属性注入-->
   	<property name="maps">
    	<map>
        	<entry key="JAVA" value="java"></entry>
            <entry key="PHP" value="php"></entry>
        </map>
	</property>
    <!--使用set标签进行set类型属性注入-->
    <property name="sets">
    	<set>
        	<value>MySQL</value>
            <value>Redis</value>
		</set>
	</property>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

二、在集合里面设置对象类型值
新建src/com/atguigu/spring5/collectiontype/Course.java文件，代码如下：

//课程类
public class Course {
    private String cname; //课程名称
    public void setCname(String cname) {
        this.cname = cname;
    }

    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在Stu类中创建一个集合，集合中存储的是Course对象，代码如下：

//学生所学多门课程
private List<Course> courseList;
public void setCourseList(List<Course> courseList) {
	this.courseList = courseList;
}
1
2
3
4
5

在bean1.xml中先创建Course对象，然后再使用ref标签引用这些对象：

<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
    <!--使用list标签注入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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

三、把集合注入部分提取出来作为公共部分，让其他地方也可以用到它：新建src/com/atguigu/spring5/collectiontype/Book.java文件，代码如下：

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

    public void test() {
        System.out.println(list);
    }
}
1
2
3
4
5
6
7
8
9
10

新建配置文件bean2.xml，并引入名称空间util

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

<!--1 提取list集合类型属性注入
因为是list集合，所以使用的是util:list标签，如果是map，使用util:map标签

-->
<util:list id="bookList">
	<value>易筋经</value>
    <value>九阴真经</value>
    <value>九阳神功</value>
</util:list>

<!--2 提取list集合类型属性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
	<property name="list" ref="bookList"></property>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14