1.Spring概述
1.1 Spring框架是什么
Spring是与2003年兴起的一个轻量级的Java开发框架,它是为了解决企业应用开发的复杂性而创建的。Spring的核心是控制反转(IOC)和面向切面编程(AOP)。Spring是可以在Java SE/EE中使用的轻量级开源框架。
Spring的主要作用就是为代码"解耦",降低代码间的耦合度。就是让对象和对象(模板和模板)之间关系不是使用代码关联,而是通过配置来说明。即在Spring中说明对象(模块)的关系。
Spring根据代码的功能特点,使用IOC降低业务对象之间耦合度。IOC使得主业务在相互调用过程中,不用再自己维护关系了,即不用再自己创建要使用的对象了,而是由Spring容器统一管理,自动"注入",注入即赋值。而AOP使得系统服务得到了最大复用,且不用再由及程序手工将系统及服务"混杂"到主业务逻辑中了,而是由Spring容器统一完成
1.2 Spring优点
1.2.1 轻量
Spring框架使用的jar都比较小,一般在1M以下或者几百kb。Spring核心功能所需的jar包总共在3M左右
Spring框架运行占用的资源少,运行效率高。不依赖其他jar包
1.2.2 针对接口编程,解耦合
Spring提供了IoC控制反转,由容器管理对象,对象的依赖关系。原来在程序代码中的对象创建方式,现在由容器完成。对象之间的依赖解耦合。
1.2.3 AOP编程的支持
通过Spring提供的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
1.2.4 方便集成各种优秀框架
Spring不排斥各种优秀的开源框架,相反Spring可以降低各种框架的使用难度,Spring提供了对各种优秀框架(如 Sruts,Hibernate,MyBatis)等的直接支持,简化框架的使用。
2 IoC控制反转
2.1 概念
IoC,Inversion of Control:控制反转,是一个理论,一个指导思想。指导开发人员如何使用对象,管理对象的。把对象的创建,属性赋值,对象的生命周期都交给代码之外的容器管理。
1.IoC分为控制和反转
控制:对象创建,属性赋值,对象生命周期管理
反转:把开发人员管理对象的权限转移给了代码之外的容器实现。由容器完成对象的管理。
正转:开发人员在代码中,使用new构造方法创建对象。开发人员掌握了对象的创建,属性赋值,对象从开始到销毁的全部过程。开发人员有对 对象的全部控制。
通过容器,可以使用容器中的对象(容器已经创建了对象,对象属性赋值了,对象也组装好了)
2.IoC技术的实现
DI(依赖注入):Dependency Injection,缩写是DI。是IoC的一种技术实现。程序只需要提供要使用的对象的名称就可以了。对象如何创建,如何从容器中查找,获取都是由容器内部自己实现。
依赖名词:比如说ClassA类使用了ClassB的属性或者方法,叫做ClassA依赖ClassB
public class ClassB{
public void createOrder() {
}
}
public class ClassA{
//属性
private ClassB b = new ClassB();
public void buy() {
b.createOrder();
}
}
执行ClassA的buy()
ClassA a = new ClassA();
a.buy();
3.Spring框架使用的DI实现IoC
通过Spring框架,只需要提供要使用的对象名词就可以了。从容器中获取名称对应的对象
Spring底层使用的 反射机制,通过反射创建对象,给属性赋值。
2.2 第一个spring项目
我们来创建第一个Spring项目
1.创建一个空项目
2.添加新的Module
我们创建第一个项目,名称为Spring-01,创建完成后,我们来看项目目录结构
3.加入依赖,修改pom.xml
spring-context:spring依赖
junit:单元测试
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!--spring依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.4</version>
</dependency>
</dependencies>
4.开发人员定义类:接口和实现类
类也可以没有接口。
接口和实现类定义:和没有spring一样
接口的定义:
public interface SomeService {
void doSome();
}
实现类的定义:
import com.lu.service.SomeService;
public class SomeServiceImpl implements SomeService {
@Override
public void doSome() {
System.out.println("执行了业务方法doSome()...");
}
}
5.创建spring的配置文件
作用:声明对象
把对象交给spring创建和管理
使用表示对象生命,一个bean表示一个java对象
<?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">
</beans>
spring标准的配置文件:
1.根标签是 beans
2.beans后面的是约束文件说明
3.beans里面是bean生命
4.什么是bean:bean就是java对象,spring容器管理的java对象,叫做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">
<!--声明对象
id:自定义对象名称,唯一值(可以没有,spring可以提供默认名称)
class:类的全限定名称,spring通过反射机制创建对象,不能是接口
spring根据id,class创建对象,把对象放入到spring的一个map对象。
map.put(id,对象)
-->
<bean id="someService" class="com.lu.service.impl.SomeServiceImpl"></bean>
</beans>
6.使用容器中的对象
创建一个表示spring容器的对象 AppplicationContext
从容器中,根据名称获取对象,使用getBean(“对象名称”)
package com.lu;
import com.lu.service.SomeService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void testdoSomething() {
//SomeService service = new SomeServiceImpl();
//service.doSome();
//1.指定spring配置文件:从类路径(classpath)之下开始的路径
String config="beans.xml";
//2.创建容器对象 ApplicationContext 表示spring容器对象。通过ctx获取某个java对象
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//3.从容器中获取指定名称的对象,使用getBean("id")
SomeService service = (SomeService)ctx.getBean("someService");
//4.调用对象的方法
service.doSome();
}
}
我们来运行一下:
成功运行!
2.3 三个问题的探究
1.我们来思考一个问题,通过spring来创建对象,是调用的类的无参构造函数吗?
我们来测试一下,我们现在实现类中定义一个无参构造方法
package com.lu.service.impl;
import com.lu.service.SomeService;
public class SomeServiceImpl implements SomeService {
public SomeServiceImpl() {
System.out.println("无参构造");
}
@Override
public void doSome() {
System.out.println("执行了业务方法doSome()...");
}
}
然后在测试类中测试
//spring创建对象,调用的是类的哪个方法?
@Test
public void test01() {
String config = "beans.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//SomeService service = ctx.getBean(SomeService.class);
//service.doSome();
SomeService service = (SomeService) ctx.getBean("someService");
service.doSome();
}
控制台输出:
看来真的是调用了无参构造方法,也就是说spring默认调用的是无参构造方法,也就是说我们在类中有有参构造方法的话,我们必须显示的声明无参构造方法
2.我们再来思考一个问题,spring是在什么时候创建的对象?
我们来写代码测试一下
//spring是在什么时候创建的对象?
@Test
public void test02() {
String config = "beans.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//SomeService service = (SomeService) ctx.getBean("someService");
//service.doSome();
}
我们把后面两行注释掉,跑一下代码
出来无参构造了,说明对象创建了,也就是说创建spring容器对象的时候,会读取配置文件,创建文件中声明的Java对象
这样做的优点是:
获取对象的速度快,因为对象已经创建好了
缺点:
占用内存
3.我们再来思考第三个问题,spring容器创建对象,一次创建几个呢?
我们来修改一下beans.xml文件
<?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="someService" class="com.lu.service.impl.SomeServiceImpl"></bean>
<bean id="someService" class="com.lu.service.impl.SomeServiceImpl"></bean>
</beans>
跑一下测试类
//spring容器创建对象,一次创建几个
@Test
public void test03() {
String config = "beans.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//SomeService service = (SomeService) ctx.getBean("someService");
//service.doSome();
}
输出一下
我们发现出来两个对象,也就是说:
在创建容器(ApplicationContext)对象时,会把配置文件中的所有对象都创建出来(spring的默认规则)
2.4 spring容器创建对象的特点
1.容器对象ApplicationContext:接口
通过ApplicationContext对象,获取要使用的其他Java对象,执行getBean(“的id”)
2.spring默认时调用类的无参构造方法,创建对象
3.spring读取配置文件,一次创建好所有的Java对象,都放到map中
2.4.1 获取容器中定义的对象信息
我们获取容器中定义的对象信息主要通过两个方法
getBeanDefinitionCount() //获取容器中定义对象的数量
getBeanDefinitionNames() //获取容器中定义的对象名称
我们来编写测试类:
@Test
public void test04() {
String config = "beans.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
//获取容器中定义对象的数量
int nums = ctx.getBeanDefinitionCount();
System.out.println("容器中定义对象的数量==" + nums);
//获取容器中定义的对象名称
String names[] = ctx.getBeanDefinitionNames();
for (String name :
names) {
System.out.println("容器中对象的名称==" + name);
}
}
控制台输出:
我们可以看到我们已经获取到容器中定义的对象信息。
2.4.2 spring创建非自定义类对象
刚才的例子我们的对象都是创建的自己定义的类的对象,那么spring如何创建非自定义类的对象呢,比如Date类
我们先来修改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="mydate" class="java.util.Date"></bean>
</beans>
来编写测试类:
//spring创建非自定义类的对象
//有class就能让spring创建对象
@Test
public void test05() {
String config = "beans.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
Date date = (Date) ctx.getBean("mydate");
System.out.println("date==" + date);
}
控制台输出:
我们看到Date类的对象创建成功了
2.4.3 没有接口的类创建对象
上面我们都是创建的有接口的类的对象,那么spring能否创建没有接口的类的对象呢
我们来试验一下,首先创建一个类,该类没有实现接口
package com.lu.service;
public class OtherService {
public void doOther() {
System.out.println("执行OtherService的doOther()");
}
}
beans.xml文件
<?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="otherService" class="com.lu.service.OtherService"></bean>
</beans>
编写测试类:
@Test
public void test06() {
String config = "beans.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
OtherService service = (OtherService) ctx.getBean("otherService");
service.doOther();
}
控制台输出:
我们发现创建成功了,也就是说spring创建对象只需要拿到beans文件中的id即可
2.5 DI:属性赋值
spring调用类的无参构造方法,创建对象。对象创建后给属性赋值。
给属性赋值可以使用:
- xml配置文件中的标签和属性
- 使用注解
DI分类:
- set注入,也叫做设值注入
- 构造注入
2.5.1 基于xml的DI
在xml配置文件中使用标签和属性,完成对象创建,属性赋值
2.5.1.1 set注入,也叫做设值注入
概念:spring调用类中的set方法,在set方法中可以完成属性赋值。推荐使用!
我们来实现一下,新建一个项目,叫做Spring-02,完成后的项目结构为:
首先创建一个Student类
package com.lu.test01;
public class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
来编写xml文件
<?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="myStudent" class="com.lu.test01.Student"></bean>
</beans>
编写测试类:
@Test
public void test01() {
String config = "test01/applicationContext.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
Student student = (Student) ctx.getBean("myStudent");
System.out.println("student == " + student);
}
控制台输出:
我们发现对象创建成功了,但是还没有赋值,现在我们要做的工作就是给属性赋值。
我们来重新编写applicationContext.xml文件
<?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-->
<!--
DI:给属性赋值
简单类型:java中的基本数据类型和String
1.set注入:spring调用类的set方法,通过set方法完成属性赋值
简单类型的set注入:
语法:<bean id="xxx" class="yyyy">
<property name="属性名" value="简单类型属性值"/>
....
</bean>
-->
<bean id="myStudent" class="com.lu.test01.Student">
<property name="name" value="张三"></property>
<property name="age" value="20"></property>
</bean>
</beans>
语法格式在上面已经说明了,我们重新来跑一下测试类:
这里我们需要说明几点,
-
第一点是定义的类中属性必须要有对应的set方法,否则会报错
-
第二点是set方法里面可以随便定义,不一定非得有赋值语句,如果没有赋值语句,就不会赋值,但不会报错
-
第三点是如果set方法没有对应的属性值,也是可以执行的,只是只会执行该set方法,不会对不存在属性进行赋值
2.5.1.1.1 给非自定义类的属性赋值
上面我们举的例子是给自定义的类的属性进行赋值,那么如何给非自定义的类的属性赋值呢?
我们拿Date类来举一个例子
我们去查看Date类的源代码,发现set方法是下面这一个
也就是说我们需要给time进行赋值,且time是简单类型
我们再xml文件中进行修改
<?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="mydate" class="java.util.Date">
<property name="time" value="2432115451534"></property>
</bean>
</beans>
编写测试类:
@Test
public void test02() {
String config = "test01/applicationContext.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
Date date = (Date) ctx.getBean("mydate");
System.out.println("date == " + date);
}
控制台输出:
我们看到由于我们自己设置了值,现在的时间到达了2047年
2.5.1.1.2 给引用类型赋值
我们重新创建一个包,包结构如下:
我们首先定义一个School类
package com.lu.test02;
public class School {
private String name;
private String address;
public void setName(String name) {
this.name = name;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "School{" +
"name='" + name + '\'' +
", address='" + address + '\'' +
'}';
}
}
再定义一个Student类
package com.lu.test02;
public class Student {
private String name;
private int age;
//引用类型
private School school;
public Student() {
System.out.println("Student类的无参构造方法执行了....");
}
public void setName(String name) {
System.out.println("setName == " + name);
this.name = name;
}
public void setAge(int age) {
System.out.println("setAge == " + age);
this.age = age;
}
public void setSchool(School school) {
System.out.println("setSchool == " + school);
this.school = school;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school=" + school +
'}';
}
}
我们来编写applicationContext.xml文件
<?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-->
<!--
DI:给属性赋值
简单类型:java中的基本数据类型和String
1.set注入:spring调用类的set方法,通过set方法完成属性赋值
简单类型的set注入:
语法:<bean id="xxx" class="yyyy">
<property name="属性名" value="简单类型属性值"/>
....
</bean>
2.set注入:
引用类型set注入:
语法:
<bean id="xxx" class="yyy">
<property name="属性名" ref="bean的id"/>
...
</bean>
-->
<bean id="myStudent" class="com.lu.test02.Student">
<property name="name" value="张三"></property>
<property name="age" value="20"></property>
<property name="school" ref="mySchool"></property>
</bean>
<!--声明school-->
<bean id="mySchool" class="com.lu.test02.School">
<property name="name" value="清华大学"></property>
<property name="address" value="北京"></property>
</bean>
</beans>
我们来编写测试类:
@Test
public void test01() {
String config = "test02/applicationContext.xml";
ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
Student student = (Student)ctx.getBean("myStudent");
System.out.println(student);
}
控制台输出:
我们可以看到,对于引用类型的赋值,我们必须使用ref来引用
格式为:
<bean id="xxx" class="yyy">
<property name="属性名" ref="引用类型的bean的id"/>
...
</bean>
2.5.1.2 构造注入
构造注入:spring调用类中的有参构造方法,在创建对象的同时,给属性赋值。
我们举个例子,首先修改Student类,School类不需要修改
package com.lu.test03;
public class Student {
private String name;
private int age;
//引用类型
private School school;
public Student() {
System.out.println("Student类的无参构造方法执行了....");
}
public Student(String name, int age, School school) {
System.out.println("Student的有参构造方法执行了...");
this.name = name;
this.age = age;
this.school = school;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", school=" + school +
'}';
}
}
再来修改applicationContext.xml文件
<?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">
<!--
构造注入:spring调用类的有参构造方法,创建对象同时给属性赋值
语法:
<bean id="xxx" class="yyy">
<constructor-arg>:表示一个构造方法的形参
标签有属性:name:构造方法形参名
index:构造方法的参数位置
value:简单类型的形参值
ref:引用类型的形参值
-->
<bean id="myStudent" class="com.lu.test03.Student">
<constructor-arg name="name" value="李四"></constructor-arg>
<constructor-arg name="age" value="25"></constructor-arg>
<constructor-arg name="school" ref="mySchool"></constructor-arg>
</bean>
<!--声明school-->
<bean id="mySchool" class="com.lu.test03.School">
<property name="name" value="清华大学"></property>
<property name="address" value="北京"></property>
</bean>
</beans>
我们来编写测试类:
package com.lu;
import com.lu.test03.Student;
import org.junit.Test;
import org.springframework