spring5
目录
- 入门案例
- IOC
-
- IOC操作Bean管理
-
- 基于xml配置文件方式实现Bean管理操作
-
- 基于xml方式创建对象
- 基于xml方式注入属性
- 基于xml方式注入其他类型属性
-
- 注入字面量
- 注入属性
-
- 外部bean
- 内部bean
- 级联赋值
- xml注入集合属性
入门案例
一、下载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......");
}
}
以前通过new就可以创建这个类的对象，但是现在我们想通过spring5实现创建对象，可以通过注解、配置文件的方式实现，我们现在先来感受一下配置文件的实现方法，进行下面的步骤：
五、创建Spring配置文件，在配置文件配置创建的对象：Spring配置文件使用xml格式，所以新建src/bean1.xml，在里面进行创建User类对象的相关配置，这里面有个bean标签，专门用来进行创建对象的相关配置，bean标签的两个属性：
id：指定bean标签的idclass：指定类的全路径（包+类名）
<bean id="user" class="com.atguigu.spring5.User">bean>
六、编写测试代码
新建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();
}
}
IOC
一、什么是 IOC
- 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理
- 使用IOC目的：为了耦合度降低
- 做入门案例就是IOC实现
二、IOC底层原理：xml 解析、工厂模式、反射
示例：假如我想在service类中调用dao类的方法，以前的方法是在service类中创建dao对象，然后直接通过对象调用方法，这样耦合度太高，现在我们使用IOC通过xml解析和反射的方式实现：
- 在xml配置文件中配置创建的对象：
- 有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();
}
}
反射：得到类的字节码文件
三、IOC接口
- IOC思想基于IOC容器完成，容器底层就是对象工厂，在这个工厂里面读取配置文件，通过反射创建对象。
- Spring提供IOC容器实现两种方式，即两个接口：
（1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用
加载配置文件时不会创建对象，在获取对象（使用）才去创建对象
使用：在src/com/atguigu/spring5/testdemo/TestSpring5.java中使用BeanFactory加载spring配置文件:BeanFactory context = new ClassPathXmlApplicationContext("bean1.xml");
（2）ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
加载配置文件时候就会把在配置文件对象进行创建
ApplicationContext接口有实现类，他们都在src/com/atguigu/spring5/testdemo/TestSpring5.java中加载spring配置文件时使用
（1）ApplicationContext context = new FileSystemXmlApplicationContext(配置文件在系统盘里的路径);
（2）ApplicationContext context = new ClassPathXmlApplicationContext(src下的类路径);
IOC操作Bean管理
一、Bean管理指的是两个操作：
- 使用Spring创建对象，如入门案例
- 使用Spirng注入属性：使用spring给类中的属性创建
setter
二、Bean管理操作有两种方式：
- 基于xml配置文件方式实现
- 基于注解方式实现
基于xml配置文件方式实现Bean管理操作
基于xml方式创建对象
一、在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
二、在bean标签有很多属性，介绍常用的属性
id属性：唯一标识class属性：类全路径（包类路径）
三、创建对象时候，默认是执行无参数构造方法完成对象创建，如果你在类中创建了有参构造方法而没有写无参构造方法，相当于此时类中没有无参构造方法，会报错
<bean id="user" class="com.atguigu.spring5.User">bean>
基于xml方式注入属性
一、DI是IOC的具体实现，他表示依赖注入，就是注入属性，但他需要在创建对象的基础上完成属性注入，即先创建对象再注入属性
二、第一种注入方式：使用set方法进行注入
- 创建类，定义属性和对应的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;
}
}
- 在spring配置文件
bean1.xml配置对象创建，配置属性注入
<bean id="book" class="com.atguigu.spring5.Book">
<property name="bname" value="易筋经">property>
<property name="bauthor" value="达摩老祖">property>
bean>
优化：前面我们在spring配置文件
bean1.xml中进行属性注入时，你有多少个属性就要使用property属性写多少行，很繁琐：
<property name="bname" value="易筋经">property>
<property name="bauthor" value="达摩老祖">property>
我们可以使用p名称空间注入属性来简化
- 添加p名称空间在配置文件中
- 进行属性注入，在
bean标签里面进行操作，直接在bean标签中简化写：p.属性名=“属性值”，如下：
<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏">bean>-->
上述代码等同于：
<bean id="book" class="com.atguigu.spring5.Book">
<property name="bname" value="易筋经">property>
<property name="bauthor" value="达摩老祖">property>
bean>
优化结束
- 在
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();
}
}
三、第二种注入方式：使用有参数构造进行注入
- 创建类，定义属性，创建属性对应有参数构造方法
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);
}
}
（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>
（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();
}
}
基于xml方式注入其他类型属性
注入字面量
一、null值：给Book类的address属性设为null值，bean1.xml中的bean标签中的property标签中不再配置value属性，而是在property标签中直接写个
<bean id="book" class="com.atguigu.spring5.Book">
<property name="address">
<null/>
property>
bean>
二、属性值包含特殊符号：
- 在
bean1.xml中的bean标签中的property标签中配置value属性时，将特殊字符进行转义，如把<、>分别转义为<和>
<bean id="book" class="com.atguigu.spring5.Book">
<property name="address" value="<<南京>>">property>
bean>
- 在
bean1.xml中的bean标签中的property标签中不再配置value属性，而是写value标签，并把带特殊符号内容写到CDATA中，即，将CDATA作为value标签内容，如下：
<bean id="book" class="com.atguigu.spring5.Book">
<property name="address">
<value>>]]>value>
property>
bean>
注入属性
注入属性有两种方式：内部bean、外部bean
外部bean
一、操作中应该有三层：web层调用service层，service层调用DAO层，通过service层调用DAO层就被称为引入外部bean
二、步骤：
- 创建两个类
service类和dao类：
新建src/com/atguigu/spring5/service/UserService.java，代码如下：
public class UserService {
public void add() {
System.out.println("service add...............");
}
}
新建src/com/atguigu/spring5/dao文件夹，该文件夹下新建UserDao接口UserDao.java代码如下：
public interface UserDao {
public void update();
}
及其实现类UserDaoImpl.java，代码如下：
public class UserDaoImpl implements UserDao {
@Override
public void update() {
System.out.println("dao update...........");
}
}
- 在
service调用dao里面的方法
方法一：普通方法：在service中创建dao对象，通过对象调用方法，UserService.java代码如下：
public class UserService {
public void add() {
System.out.println("service add...............");
UserDso userDao = new UserDaoImpl();
userDao.update();
}
}
方法二：使用spring实现：在spring配置文件中进行配置
思路：
- 在配置文件中创建
service和dao的对象 - 将
dao注入service中，可以使用set注入、有参构造函数注入
实现：
- 在
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();
}
}
- 新建配置文件
src/bean2.xml，在其中创建service和dao的对象
<bean id="userService" class="com.atguigu.spring5.service.UserService">bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl">bean>
- 在
service中注入dao：在userService的bean标签中使用property标签实现注入
<bean id="userService" class="com.atguigu.spring5.service.UserService">
<property name="userDao" ref="userDaoImpl">property>
bean>
<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl">bean>
- 测试：新建
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();
}
}
内部bean
一、数据库表与表之间有一对一、一对多的关系，比如部门和员工就是一对多关系，一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多
二、现在我们要在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
三、内部bean：在一个对象中可以嵌套定义另一个对象
四、实现：
- 新建
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 + '\'' +
'}';
}
}
及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);
}
}
- 新建
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>
- 测试：
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();
}
}
级联赋值
一、级联赋值：可以同时向有关联的类的属性中设值，可以说是内部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>
四、第二种写法：
<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>
因为我们这里涉及给emp.dept.dname赋值的操作，所以需要为Emp的dept属性生成setter，dept属性其实就是Dept类，在Emp.java中新增代码：
public class Emp {
//生成dept的get方法
public Dept getDept() {
return dept;
}
测试，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();
}
}
xml注入集合属性
一、注入数组类型属性、注入List集合类型属性、注入Map集合类型属性
- 新建一个项目
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);
}
}
- 在spring配置文件
bean1.xml中使用各种标签进行配置：
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
<property name="courses">
<array>
<value>java课程value>
<value>数据库课程value>
array>
property>
<property name="list">
<list>
<value>张三value>
<value>小三value>
list>
property>
<property name="maps">
<map>
<entry key="JAVA" value="java">entry>
<entry key="PHP" value="php">entry>
map>
property>
<property name="sets">
<set>
<value>MySQLvalue>
<value>Redisvalue>
set>
property>
bean>
测试：新建src/com/atguigu/spring5/testdemo/TestSpring5Demo1.java，代码如下：
public class TestSpring5Demo1 {
@Test
public void testCollection1() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
Stu stu = context.getBean("stu", Stu.class);
stu.test();
}
}
二、在集合里面设置对象类型值
新建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 + '\'' +
'}';
}
}
在Stu类中创建一个集合，集合中存储的是Course对象，代码如下：
//学生所学多门课程
private List<Course> courseList;
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
在bean1.xml中先创建Course对象，然后再使用ref标签引用这些对象：
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
<property name="courseList">
<list>
<ref bean="course1">ref>
<ref bean="course2">ref>
list>
property>
bean>
<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>
三、把集合注入部分提取出来作为公共部分，让其他地方也可以用到它：新建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);
}
}
新建配置文件bean2.xml，并引入名称空间util
使用util标签完成list集合注入提取
<util:list id="bookList">
<value>易筋经value>
<value>九阴真经value>
<value>九阳神功value>
util:list>
<bean id="book" class="com.atguigu.spring5.collectiontype.Book" >
<property name="list" ref="bookList">property>
bean>
测试：TestSpring5Demo1.java代码如下：
public class TestSpring5Demo1 {
@Test
public void testCollection2() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book book1 = context.getBean("book", Book.class);
book.test();
}
}