spring5

目录

  • 入门案例
  • IOC
    • IOC操作Bean管理
      • 基于xml配置文件方式实现Bean管理操作
        • 基于xml方式创建对象
        • 基于xml方式注入属性
        • 基于xml方式注入其他类型属性
          • 注入字面量
          • 注入属性
            • 外部bean
            • 内部bean
            • 级联赋值
          • xml注入集合属性

入门案例

一、下载spring5
spring5下载地址。本文使用Spring稳定版本5.2.6
spring5_第1张图片
spring5_第2张图片
二、打开idea工具,创建普通Java工程,一路next
spring5_第3张图片
三、导入Spring5相关jar包
在这里插入图片描述
我们可以看到,spring的核心容器有四个,所以我们spring5的解压文件的Libs中找到这四个相关文件及logging文件,将这五个文件复制到spring5-test\lib文件夹下
spring5_第4张图片
并将这五个包导入到项目中:Project Structure-modules-+-jars
spring5_第5张图片
spring5_第6张图片
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标签的两个属性:

  1. id:指定bean标签的id
  2. class:指定类的全路径(包+类名)

<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

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

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

  1. 在xml配置文件中配置创建的对象:
  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();
	}
}

反射:得到类的字节码文件
三、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)ApplicationContextBeanFactory接口的子接口,提供更多更强大的功能,一般由开发人员进行使用

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

  1. ApplicationContext接口有实现类,他们都在src/com/atguigu/spring5/testdemo/TestSpring5.java中加载spring配置文件时使用
    spring5_第7张图片
    (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属性:类全路径(包类路径)

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


<bean id="user" class="com.atguigu.spring5.User">bean>
基于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. 在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名称空间注入属性来简化

  1. 添加p名称空间在配置文件中
    spring5_第8张图片
  2. 进行属性注入,在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>

优化结束

  1. 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. 创建类,定义属性,创建属性对应有参数构造方法
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>

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

  1. bean1.xml中的bean标签中的property标签中配置value属性时,将特殊字符进行转义,如把<>分别转义为<>
<bean id="book" class="com.atguigu.spring5.Book">
	<property name="address" value="<<南京>>">property>
bean>
  1. 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
二、步骤:

  1. 创建两个类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...........");
    }
}
  1. 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配置文件中进行配置
思路:

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

实现:

  1. UserService中创建UserDao类型属性,因为后面会在在service中注入dao,所以在service中生成daoset方法:
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. 新建配置文件src/bean2.xml,在其中创建servicedao的对象
<bean id="userService" class="com.atguigu.spring5.service.UserService">bean>

<bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl">bean>
  1. service中注入dao:在userServicebean标签中使用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>
  1. 测试:新建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:在一个对象中可以嵌套定义另一个对象
四、实现:

  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 + '\'' +
                '}';
    }
}

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. 新建src/bean3.xml,在其中进行内部bean配置,直接在empbean标签中的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. 测试: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赋值的操作,所以需要为Empdept属性生成setterdept属性其实就是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集合类型属性

  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. 在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
spring5_第9张图片
使用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();
    }
}

你可能感兴趣的:(spring5,java)