一、Spring
1. 简介
- Spring：春天 ------->给软件行业带来了春天
- 2002，首次推出了Spring框架的雏形：interface21框架
- Spring框架即是以interface21框架为基础经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版
- Rod Johnson ,Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
- Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
- SSH :Struct2 + Spring + Hibernate
- SSM：SpringMVC + SPring +Mybatis（现在学的）
- 官网：https://spring.io/
- 官方下载地址：http://repo.spring.io/release/org/springframework/spring
- GitHub：https://github.com/spring-projects/spring-framework
- Spring核心技术地址：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-annotation-config
- mvn-spring依赖地址：https://mvnrepository.com/artifact/org.springframework/spring-webmvc
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.12</version>
</dependency>
- mvn-spring-jdbc依赖地址：https://mvnrepository.com/artifact/org.springframework/spring-jdbc
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.12</version>
</dependency>
2. 优点
- Spring是一个开源的免费的框架（容器）！
- Spring是一个轻量级的，非入侵式的框架
- 控制反转（IOC），面向切面编程（AOP）
- 支持事务的处理，对框架整合的支持！
总结： Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！
3. 组成
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式 .
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
4. 扩展
在spring的官网有这个介绍：现代化的Java开发，说白就是基于Spring的开发
Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速开发的单个微服务
- 预定大于配置！
Spring Cloud
- Spring Cloud 是基于SpringBoot实现的。
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMvc!承上启下的作用！
弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱！”
二、IOC
1. 搭建环境
1. 创建项目
1. 创建spring-study空项目
创建一个spring-study空项目，删除src
2. 导入spring-webmvc依赖
spring-study父类的pom.xml 里面导入spring-webmvc依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.xxx</groupId>
<artifactId>spring-study</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<!--依赖-->
<dependencies>
<!--导入spring-webmvc依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.12</version>
</dependency>
</dependencies>
</project>
2. 创建空模块
创建空模块spring-01-ioc1
2. 分析实现
1. 原来的方式
1.UserDao接口
地址：src/main/java/com/xxx/dao/UserDao.java
代码：
package com.xxx.dao;
public interface UserDao {
void getUser();
}
2.UserDao的实现类
地址：src/main/java/com/xxx/dao/UserDaoImpl.java
代码：
package com.xxx.dao;
public class UserDaoImpl implements UserDao{
public void getUser(){
System.out.println("获取用户的数据");
}
}
3.UserService接口
地址：src/main/java/com/xxx/service/UserService.java
代码：
package com.xxx.service;
public interface UserService {
void getUser();
}
4.UserService实现类
地址：src/main/java/com/xxx/service/UserServiceImpl.java
代码：
package com.xxx.service;
import com.xxx.dao.UserDao;
import com.xxx.dao.UserDaoImpl;
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
public void getUser() {
userDao.getUser();
}
}
5. 测试
import com.xxx.service.UserServiceImpl;
public class MyTest {
public static void main(String[] args) {
//用户实际调用的是业务层，dao层他们不需要接触
UserServiceImpl service = new UserServiceImpl();
service.getUser();
}
}
结果：
获取用户的数据
进程已结束，退出代码为 0
-
这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 .
-
把Userdao的实现类增加一个 .
6.添加Userdao实现类
地址：src/main/java/com/xxx/dao/UserDaoMysqlImpl.java
代码：
package com.xxx.dao;
public class UserDaoMysqlImpl implements UserDao{
public void getUser(){
System.out.println("获取mysql的数据");
}
}
- 紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现
- 修改地址：src/main/java/com/xxx/service/UserServiceImpl.java
package com.xxx.service;
import com.xxx.dao.UserDao;
import com.xxx.dao.UserDaoImpl;
import com.xxx.dao.UserDaoMysqlImpl;
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoMysqlImpl();
public void getUser() {
userDao.getUser();
}
}
-
测试及结果
-
以此类推，假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .
-
那我们如何去解决呢 ?
-
我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .
2. 将UserService使用Set接口实现
1. 修改UserService实现类
地址：src/main/java/com/xxx/service/UserServiceImpl.java
代码：
package com.xxx.service;
import com.xxx.dao.UserDao;
import com.xxx.dao.UserDaoImpl;
import com.xxx.dao.UserDaoMysqlImpl;
public class UserServiceImpl implements UserService {
//private UserDao userDao = new UserDaoMysqlImpl();
private UserDao userDao;
//利用set进行动态实现值得注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser() {
userDao.getUser();
}
}
2. 测试
代码：
import com.xxx.dao.UserDaoImpl;
import com.xxx.dao.UserDaoMysqlImpl;
import com.xxx.dao.UserDaoOracleImpl;
import com.xxx.service.UserService;
import com.xxx.service.UserServiceImpl;
public class MyTest {
public static void main(String[] args) {
//用户实际调用的是业务层，dao层他们不需要接触
UserServiceImpl service = new UserServiceImpl();
service.setUserDao( new UserDaoMysqlImpl() );
service.getUser();
//那我们现在又想用Oracle去实现呢
service.setUserDao( new UserDaoOracleImpl() );
service.getUser();
}
}
结果：
获取mysql的数据
获取Oracle的数据
进程已结束，退出代码为 0
- 之前，程序通过new主动创建对象！控制权在程序猿手上
- 使用set注入后，程序不再具有主动性，而是变成了被动的接受对象！
- 这种思想，从本质上解决了问题，程序员不用再去管理对象的创建了，降低了耦合性！
3. IOC本质
控制反转IOC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IOC的一种方法， 也有人认为DI只是IOC的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓的控制反转就是：获得依赖的方式反转了。
IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
4.HelloSpring
新建一个空模块spring-02-hellospring
1. 编写一个实体类
地址：src/main/java/com/hello/pojo/Hello.java
代码：
package com.hello.pojo;
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
2. 编写我们的spring文件 , 这里我们命名为beans.xml
地址：src/main/resources/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就是java对象 , 由Spring创建和管理.使用Spring来创建对象，在Spring这些都成为Bean
类型 变量名= new 类型（）；
Hello hello = new Hello();
bean = 对象， new Hello()
id = 变量名
class = 全路径 new 的对象
property 相当于给对象中的属性设置一个值
-->
<bean id="hello" class="com.hello.pojo.Hello">
<property name="str" value="Spring"/>
</bean>
</beans>
3.测试
import com.hello.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
//获取spring上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在spring中管理了，我们要使用，直接去里面取出来就可以
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
结果：
Hello{str='Spring'}
进程已结束，退出代码为 0
会发现，已经不需要手动new对象，对象是在xml文件中配置。或者通俗来讲，不需要改底层代码，而xml文件不算底层代码。
控制反转
- 控制： 谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的
- 反转: 程序本身不创建对象，而变成被动的接收对象。
- 依赖注入： 就是利用set方法来进行注入的
- IOC是一种编程思想，由主动的编程变为被动的接收，所谓的IOC，即对象由Spring来创建，管理，装配
5. 修改spring-01-ioc1的实现方式
1. 添加beans.xml
路径：src/main/resources/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="mysqlImpl" class="com.xxx.dao.UserDaoMysqlImpl"/>
<bean id="oracleImpl" class="com.xxx.dao.UserDaoOracleImpl"/>
<bean id="UserServiceImpl" class="com.xxx.service.UserServiceImpl">
<!--
ref： 引用Spring容器中创建好的对象 .属性值为userDao，实体类使用id为mysqlImpl的类
value:具体的值
-->
<property name="userDao" ref="mysqlImpl"/>
</bean>
</beans>
2. 测试
代码：
import com.xxx.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTestBean {
public static void main(String[] args) {
//获取ApplicationContext;拿到spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//需要什么就直接get
UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
userServiceImpl.getUser();
}
}
结果：
获取mysql的数据
进程已结束，退出代码为 0
OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !
6. IOC创建对象的方式
新建一个空模块spring-03-ioc2
- 使用无参构造创建对象，默认
- 假设使用有参构造创建对象
1. 使用无参构造创建对象
1. 新建实体类
地址：src/main/java/com/two/pojo/User.java
代码：
package com.two.pojo;
public class User {
private String name;
public User(){
System.out.println("USER 的无参构造");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show() {
System.out.println("name = " + name);
}
}
2. 创建beans.xml
地址：src/main/resources/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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="com.two.pojo.User">
<property name="name" value="jva"/>
</bean>
</beans>
3. 测试
import com.two.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.show();
}
}
结果：
USER 的无参构造
name = jva
进程已结束，退出代码为 0
2. 使用有参构造创建对象
1. 下标赋值 Constructor argument index
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--无参构造实现-->
<!-- <bean id="user" class="com.two.pojo.User">
<property name="name" value="jva"/>
</bean>-->
<!--1. 有参构造实现方式1： 下标赋值-->
<bean id="user" class="com.two.pojo.User">
<constructor-arg index="0" value="java"/>
</bean>
</beans>
2. 变量类型赋值 Constructor argument type matching 不建议使用
<!--2. 有参构造实现方式2： 变量类型赋值 不建议使用-->
<bean id="user" class="com.two.pojo.User">
<constructor-arg type="java.lang.String" value="java2"/>
</bean>
3.变量名称赋值 Constructor argument name
<!--3. 有参构造实现方式3： 变量名称赋值 Constructor argument name-->
<bean id="user" class="com.two.pojo.User">
<constructor-arg name="name" value="ss"/>
</bean>
总结：在配置文件加载的时候，容器中管理的对象就已经初始化了
三、Spring的基础配置
1. 别名
1. 配置别名
<!--3. 有参构造实现方式3： 变量名称赋值 Constructor argument name-->
<bean id="user" class="com.two.pojo.User">
<constructor-arg name="name" value="ss"/>
</bean>
<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"/>
2. 使用别名
import com.two.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("userNew");
user.show();
}
}
运行结果
name = ss
进程已结束，退出代码为 0
2. Bean的配置
1. 新建实体类
地址：src/main/java/com/two/pojo/UserT.java
代码：
package com.two.pojo;
public class UserT {
private String name;
public UserT() {
System.out.println("UserT 的无参构造");
}
public UserT(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show() {
System.out.println("name = " + name);
}
}
2.写beans.xml配置
地址：src/main/resources/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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--3. 有参构造实现方式3： 变量名称赋值 Constructor argument name-->
<bean id="user" class="com.two.pojo.User">
<constructor-arg name="name" value="ss"/>
</bean>
<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="userNew"/>
<!--
Bean的配置
id：bean的唯一标识符，也就是相当于我们学的对象名
class：bean对象所对应的全限定名：包名+类名
name：也是别名，而且name可以同时取多个别名 name="user2 u2,u3;u4" 中间可以用空格，逗号，分号分割
-->
<bean id="userT" class="com.two.pojo.UserT" name="user2 u2,u3;u4">
<property name="name" value="黑心白莲"/>
</bean>
</beans>
3.测试
import com.two.pojo.User;
import com.two.pojo.UserT;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserT user = (UserT) context.getBean("u2");
user.show();
}
}
结果：
UserT 的无参构造
name = 黑心白莲
进程已结束，退出代码为 0
3.import
这个import。一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！
张三
李四
王五
applicationContext.xml
1. 导入代码
地址：src/main/resources/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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="beans.xml"/>
</beans>
使用的时候，直接使用总的配置就可以了。
四、DI依赖注入
1.构造器注入
前面已经介绍过，参考 2.6 IOC创建对象的方式
2.Set方式注入【重点】
依赖注入：Set注入
依赖：bean对象的创建依赖于容器！
注入：bean对象中的所有属性，由容器来注入！
1. 环境搭建
1. 实体类创建
1. Address创建
复杂类型
地址：src/main/java/com/di/pojo/Address.java
代码：
package com.di.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
1. Student创建
真实测试对象
地址：src/main/java/com/di/pojo/Student.java
代码：
package com.di.pojo;
import java.util.*;
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address.getAddress() +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
2. bean配置文件创建
beans.xml
地址：src/main/resources/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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.di.pojo.Student">
<property name="name" value="lili"/>
</bean>
</beans>
3.测试类创建
地址：src/test/java/MyTest.java
代码：
import com.di.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}
}
测试结果：
lili
进程已结束，退出代码为 0
2.完善注入信息
完善注入信息
代码：
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--实体类，实体类引入类型 -->
<bean id="addr" class="com.di.pojo.Address">
<property name="address" value="济南"/>
</bean>
<bean id="student" class="com.di.pojo.Student">
<!--第一种：普通值注入，String类型 value -->
<property name="name" value="lili"/>
<!--第二种：实体类Bean注入，实体类引入类型 ref -->
<property name="address" ref="addr"/>
<!--第三种：数组注入 -->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>水浒传</value>
<value>三国演义</value>
</array>
</property>
<!--第四种：list -->
<property name="hobbys">
<list>
<value>听歌</value>
<value>看电影</value>
<value>旅游</value>
<value>睡觉</value>
</list>
</property>
<!--第五种：map -->
<property name="card">
<map>
<entry key="身份证" value="11111111111111"/>
<entry key="银行卡" value="11111111111111"/>
</map>
</property>
<!--第六种：Set -->
<property name="games">
<set>
<value>LOL</value>
<value>COC</value>
<value>BOB</value>
</set>
</property>
<!--第七种：null -->
<property name="wife">
<null/>
</property>
<!--第八种：Properties 配置类 -->
<property name="info">
<props>
<prop key="driver">2012456</prop>
<prop key="sex">男</prop>
<prop key="username">小明</prop>
</props>
</property>
</bean>
</beans>
测试：
import com.di.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
/*
Student{
name='lili',
address=济南,
books=[红楼梦, 西游记, 水浒传, 三国演义],
hobbys=[听歌, 看电影, 旅游, 睡觉],
card={身份证=11111111111111, 银行卡=11111111111111},
games=[LOL, COC, BOB],
wife='null',
info={driver=2012456, sex=男, username=小明}}
* */
}
}
3.拓展方式注入
1. p命名注入
命名空间注入，可以直接注入属性的值。无需构造器
1. 新建实体类
User.java ：【注意：这里没有有参构造器！】
地址：src/main/java/com/di/pojo/User.java
代码：
package com.di.pojo;
public class User {
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 "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
2. 新建userbean.xml
引入p注入： xmlns:p="http://www.springframework.org/schema/p"
地址：src/main/resources/userbeans.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"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p 命名空间注入，可以直接注入属性的值-->
<bean id="user" class="com.di.pojo.User" p:name="zhangsan" p:age="18"/>
</beans>
3. 测试
代码：test2
import com.di.pojo.Student;
import com.di.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
/*
Student{
name='lili',
address=济南,
books=[红楼梦, 西游记, 水浒传, 三国演义],
hobbys=[听歌, 看电影, 旅游, 睡觉],
card={身份证=11111111111111, 银行卡=11111111111111},
games=[LOL, COC, BOB],
wife='null',
info={driver=2012456, sex=男, username=小明}}
* */
}
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
//指定class,就不用转换了
User user = context.getBean("user", User.class);
System.out.println(user);
}
}
结果：
User{name='zhangsan', age=18}
进程已结束，退出代码为 0
2. c命名注入
通过构造器注入，必须有构造器
1. 修改实体类
User.java ：通过构造器注入，必须有构造器
地址：src/main/java/com/di/pojo/User.java
代码：
package com.di.pojo;
public class User {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = 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 "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
2.userbean.xml添加
添加c注入代码： xmlns:c="http://www.springframework.org/schema/c"
地址：src/main/resources/userbeans.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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p 命名空间注入，可以直接注入属性的值: property-->
<bean id="user" class="com.di.pojo.User" p:name="zhangsan" p:age="18"/>
<!--c 命名空间注入，通过构造器注入，constructs-args-->
<bean id="user2" class="com.di.pojo.User" c:age="18" c:name="kk"/>
</beans>
3.测试
代码：test3
import com.di.pojo.Student;
import com.di.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
/*
Student{
name='lili',
address=济南,
books=[红楼梦, 西游记, 水浒传, 三国演义],
hobbys=[听歌, 看电影, 旅游, 睡觉],
card={身份证=11111111111111, 银行卡=11111111111111},
games=[LOL, COC, BOB],
wife='null',
info={driver=2012456, sex=男, username=小明}}
* */
}
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user", User.class);
System.out.println(user);
}
@Test
public void test3(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = context.getBean("user2", User.class);
System.out.println(user);
}
}
结果：
User{name='kk', age=18}
进程已结束，退出代码为 0
注意点：p命名和c命名空间不能直接使用，需要导入xml约束！
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
4.bean的作用域
6个
1.单例模式（Spring默认机制）
<bean id="user2" class="com.di.pojo.User" c:age="18" c:name="kk" scope="singleton"/>
2. 原型模式：每次从容器中get的时候，都会产生一个新对象！
<bean id="user2" class="com.di.pojo.User" c:name="狂神" c:age="22" scope="prototype"/>
其余的request、session、application、这些只能在web开发中使用到！
五、Bean的自动装配
- 自动装配是Spring满足bean依赖一种方式！
- Spring会在上下文中自动寻找，并自动给bean装配属性！
- 在Spring中有三种装配的方式：
- 在xml中显式的配置；
- 在java中显式配置；
- 隐式的自动装配bean【重要】
1. 环境搭建
1. 实体类
1. Dog实体类
地址：src/main/java/com/autowired/pojo/Dog.java
代码：
package com.autowired.pojo;
public class Dog {
public void shout(){
System.out.println("wang~~~");
}
}
2. Cat实体类
地址：src/main/java/com/autowired/pojo/Cat.java
代码：
package com.autowired.pojo;
public class Cat {
public void shout(){
System.out.println("miao~~~");
}
}
3.people实体类
地址：src/main/java/com/autowired/pojo/People.java
代码：
package com.autowired.pojo;
public class People {
private Dog dog;
private Cat cat;
private String name;
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"dog=" + dog +
", cat=" + cat +
", name='" + name + '\'' +
'}';
}
}
2. beans.xml配置
地址：src/main/resources/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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--宠物类-->
<bean id="cat" class="com.autowired.pojo.Cat"/>
<bean id="dog" class="com.autowired.pojo.Dog"/>
<!--一个人有两个宠物！-->
<bean id="people" class="com.autowired.pojo.People">
<property name="name" value="自动装配"/>
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
</bean>
</beans>
3. 测试
import com.autowired.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getDog().shout();
people.getCat().shout();
}
}
结果：
wang~~~
miao~~~
进程已结束，退出代码为 0
2. ByName自动装配
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--宠物类-->
<bean id="cat" class="com.autowired.pojo.Cat"/>
<bean id="dog" class="com.autowired.pojo.Dog"/>
<!--一个人有两个宠物！
byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
-->
<bean id="people" class="com.autowired.pojo.People" autowire="byName">
<property name="name" value="自动装配"/>
</bean>
</beans>
3. ByType自动装配
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--宠物类-->
<bean id="cat" class="com.autowired.pojo.Cat"/>
<bean id="dog" class="com.autowired.pojo.Dog"/>
<!--一个人有两个宠物！
byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
-->
<bean id="people" class="com.autowired.pojo.People" autowire="byType">
<property name="name" value="自动装配"/>
</bean>
</beans>
小结：
- ByName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
- ByType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！
4.使用注解实现自动装配
- jdk1.5支持的注解，Spring2.5就支持注解了！
1. 导入约束：contest约束
在spring配置文件中引入context文件头
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
2.配置注解的支持
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--开启注解的支持 -->
<context:annotation-config/>
</beans>
3.@Autowired
-
直接在属性上使用即可！也可以在set方法上使用！
-
使用Autowired我们就可以不用编写set方法了，前提是你这个自动配置的属性在IOC（Spring）容器中存在，且符合名字ByName！
-
@Autowired是按类型自动转配的，不支持id匹配。
-
需要导入 spring-aop的包！
1. 实体类
没有实体类的set方法
地址：src/main/java/com/autowired/pojo/People.java
代码：
package com.autowired.pojo;
import org.springframework.beans.factory.annotation.Autowired;
public class People {
@Autowired
private Dog dog;
@Autowired
private Cat cat;
private String name;
public Dog getDog() {
return dog;
}
public Cat getCat() {
return cat;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"dog=" + dog +
", cat=" + cat +
", name='" + name + '\'' +
'}';
}
}
2. beans.xml
地址：src/main/resources/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"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd"
>
<!--开启注解的支持 -->
<context:annotation-config/>
<!--宠物类-->
<bean id="cat" class="com.autowired.pojo.Cat"/>
<bean id="dog" class="com.autowired.pojo.Dog"/>
<bean id="people" class="com.autowired.pojo.People" />
</beans>
3. 测试
import com.autowired.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getDog().shout();
people.getCat().shout();
}
}
结果：
wang~~~
miao~~~
进程已结束，退出代码为 0
4. 科普
1. @Nullable：字段可以为null
@Nullable 字段标记了了这个注解，说明这个字段可以为null;
package com.autowired.pojo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.lang.Nullable;
public class People {
@Autowired
private Dog dog;
@Autowired
private Cat cat;
private String name;
//设置@Nullable,表示这个参数可以为null，不报错
public People(@Nullable String name) {
this.name = name;
}
}
2. @Autowired(required = false)：对象可以为null
@Autowired(required = false) 如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
public class People {
//如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
5. Qualifier
指定唯一的bean对象注入
- 如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！
- @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
- @Qualifier不能单独使用。
- 如下面实例，一个实体类有两个实现，如果不指定对象注入，会运行报错
1. 实体类
代码：
package com.autowired.pojo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.lang.Nullable;
public class People {
@Autowired
@Qualifier(value = "dog222")
private Dog dog;
@Autowired
@Qualifier(value = "cat222")
private Cat cat;
private String name;
public Dog getDog() {
return dog;
}
public Cat getCat() {
return cat;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"dog=" + dog +
", cat=" + cat +
", name='" + name + '\'' +
'}';
}
}
2. 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"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd"
>
<!--开启注解的支持 -->
<context:annotation-config/>
<!--宠物类-->
<bean id="cat111" class="com.autowired.pojo.Cat"/>
<bean id="cat222" class="com.autowired.pojo.Cat"/>
<bean id="dog111" class="com.autowired.pojo.Dog"/>
<bean id="dog222" class="com.autowired.pojo.Dog"/>
<bean id="people" class="com.autowired.pojo.People" />
</beans>
3. 测试
import com.autowired.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getDog().shout();
people.getCat().shout();
}
}
结果：
wang~~~
miao~~~
进程已结束，退出代码为 0
6.@Resource
JDK版本有些不支持@Resource，需要导入依赖包，从maven官网搜索。
-
@Resource如有指定的name属性，先按该属性进行byName方式查找装配；
-
其次再进行默认的byName方式进行装配；
-
如果以上都不成功，则按byType的方式自动装配。
都不成功，则报异常。
1. 实体类
public class User {
//如果允许对象为null，设置required = false,默认为true
@Resource(name = "cat222")
private Cat cat;
@Resource(name = "dog222")
private Dog dog;
private String str;
}
2. 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"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd"
>
<!--开启注解的支持 -->
<context:annotation-config/>
<!--宠物类-->
<bean id="cat" class="com.autowired.pojo.Cat"/>
<bean id="cat222" class="com.autowired.pojo.Cat"/>
<bean id="dog" class="com.autowired.pojo.Dog"/>
<bean id="dog222" class="com.autowired.pojo.Dog"/>
<bean id="people" class="com.autowired.pojo.People" />
</beans>
3.测试
import com.autowired.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getDog().shout();
people.getCat().shout();
}
}
结果：
wang~~~
miao~~~
进程已结束，退出代码为 0
5.小结：
@Resource和@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType的方式实现，当匹配多个同类型时候，使用ByName进行装配，而且必须要求这个对象存在！【常用】
- @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
二者对比
| @Autowired | @Resource |
|---|---|
| Spring定义的注解 | JSR-250定义的注解 |
| 默认按类型自动装配 | 默认按名称自动装配 |
| 一个参数：required(默认true)，表示是否必须注入 | 七个参数：最重要的两个参数是name、type |
| 默认按类型自动装配。 如果要按名称自动装配，需要使用@Qualifier一起配合 | 默认按名称自动装配 。 如果指定了name，则按名称自动装配；如果指定了type，则按类型自动装配 |
| 作用范围：构造器、方法、参数、成员变量、注解 | 作用范围：类、成员变量、方法 |
六、使用注解开发
- 在Spring4之后，要使用注解开发，必须要保证aop的包导入了
- 使用注解需要导入约束，配置注解的支持！
- 路径：src/main/resources/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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--开启注解的支持 -->
<context:annotation-config/>
</beans>
1. bean
- 我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！
- 创建空模块spring-06-anno，进行开发学习
1. 实体类
地址：src/main/java/com/anno/pojo/User.java
在指定包下编写类，增加注解：@Component 等价于 <bean id="user" class="com.anno.pojo.User"/>
代码：
package com.anno.pojo;
import org.springframework.stereotype.Component;
//等价于 <bean id="user" class="com.anno.pojo.User"/>
//@Component 组件
@Component
public class User {
public String name = "juli";
}
2.applicationContext.xml
地址：src/main/resources/applicationContext.xml
指定注解扫描包： <context:component-scan base-package="com.anno.pojo"/>
代码：
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.anno.pojo"/>
<!--开启注解的支持 -->
<context:annotation-config/>
</beans>
3.测试
import com.anno.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = context.getBean("user", User.class);
System.out.println(user.name);
}
}
结果：
juli
进程已结束，退出代码为 0
2.属性如何注入
1. 可以不用提供set方法，直接在直接名上添加@value(“值”)
package com.anno.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于 <bean id="user" class="com.anno.pojo.User"/>
//@Component 组件
@Component
public class User {
//相当于 <property name="name" value="JULI"/>
@Value("JULI")
public String name;
}
2.如果提供了set方法，在set方法上添加@value(“值”);
package com.anno.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于 <bean id="user" class="com.anno.pojo.User"/>
//@Component 组件
@Component
public class User {
public String name;
//相当于 <property name="name" value="JULI"/>
@Value("JULI")
public void setName(String name) {
this.name = name;
}
}
3. 衍生的注解
我们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！
@Component三个衍生注解
-
为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。
-
@Controller：web层
package com.anno.controller;
import org.springframework.stereotype.Controller;
@Controller
public class UserController {
}
- @Service：service层
package com.anno.service;
import org.springframework.stereotype.Service;
@Service
public class UserService {
}
- @Repository：dao层
package com.anno.dao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDao {
}
- 写上这些注解，就相当于将这个类交给Spring管理装配了！
- 这四个注解功能是一样的，都是代表将某个类注册到Sprig中，装配Bean
4. 自动装配
- @Autowired：自动装配通过类型，名字。
- 如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")去配置。
- @Nullable 字段标记了了这个注解，说明这个字段可以为null;
- @Resource：自动装配通过名字，类型。
5. 作用域
@scope
-
singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
-
prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收
package com.anno.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
//等价于 <bean id="user" class="com.anno.pojo.User"/>
//@Component 组件
@Component
@Scope("prototype")
public class User {
public String name;
//相当于 <property name="name" value="JULI"/>
@Value("JULI")
public void setName(String name) {
this.name = name;
}
}
6. 小结
XML与注解比较
-
XML可以适用任何场景 ，结构清晰，维护方便
-
注解不是自己提供的类使用不了，开发简单方便
xml与注解整合开发 ：推荐最佳实践
-
xml管理Bean
-
注解完成属性注入
-
使用过程中， 只需要注意一个问题：必须让注解生效，就需要开启注解的支持
<!--指定要扫描的包，这个包下的注解就会生效-->
<context:component-scan base-package="com.kuang"/>
<!--开启注解的支持 -->
<context:annotation-config/>
作用：
-
进行注解驱动注册，从而使注解生效
-
用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
-
如果不扫描包，就需要手动配置bean
-
如果不加注解驱动，则注入的值为null！
七、基于Java类进行配置Spring
- 我们现在要完全不使用Spring的xml配置了，全权交给Java来做！
- JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。
1. 新建实体类
地址：src/main/java/com/appconfig/pojo/User.java
代码：
package com.appconfig.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("jaly")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
2.新建一个config配置包，编写一个AppConfig配置类
地址：src/main/java/com/appconfig/config/AppConfig.java
代码：
package com.appconfig.config;
import com.appconfig.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
// @Configuration代表这是一个配置类，就和我们之前看的beans.xml
@Configuration
//扫描包
@ComponentScan("com.appconfig.pojo")
//
public class AppConfig {
//注册一个bean,就相当于我们之前写的一个bean标签
// 这个方法的名字，就相当于bean标签中的id属性
// 这个方法的返回值，就相当于bean标签中的class属性
@Bean
public User user(){
return new User();//就是返回要注入到bean的对象
}
}
3.测试
import com.appconfig.config.AppConfig;
import com.appconfig.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
public static void main(String[] args) {
//如果完全使用了配置类方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
User user = context.getBean("user",User.class);//取方法名
System.out.println(user.getName());
}
}
结果：
jaly
进程已结束，退出代码为 0
4.导入其他配置
1. 新建配置类
地址：src/main/java/com/appconfig/config/AppConfig2.java
代码：
package com.appconfig.config;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig2 {
}
2. 在之前的配置类中我们来选择导入这个配置类
地址：src/main/java/com/appconfig/config/AppConfig.java
使用@Import(AppConfig2.class) 导入其他配置类
代码：
package com.appconfig.config;
import com.appconfig.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
// @Configuration代表这是一个配置类，就和我们之前看的beans.xml
@Configuration
//扫描包
@ComponentScan("com.appconfig.pojo")
// 引入配置类
@Import(AppConfig2.class)
public class AppConfig {
//注册一个bean,就相当于我们之前写的一个bean标签
// 这个方法的名字，就相当于bean标签中的id属性
// 这个方法的返回值，就相当于bean标签中的class属性
@Bean
public User user(){
return new User();//就是返回要注入到bean的对象
}
}
关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！
八、代理模式
为什么要学习代理模式？因为这就是SpringAOP的底层，AOP的底层机制就是动态代理！【SpringAOP和SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
1. 静态代理
静态代理角色分析
- 抽象角色 : 一般使用接口或者抽象类来实现
- 真实角色 : 被代理的角色
- 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .
- 客户：访问代理对象的人，使用代理角色来进行一些操作 ！
1. 代码实现
新建模块spring-08-proxy
1. Rent . java 出租房接口类 即抽象角色
地址：src/main/java/com/proxy/demo01/Rent.java
代码：
package com.proxy.demo01;
/*
租房接口类
*/
public interface Rent {
public void rent();
}
2. Host . java 房东即真实角色
地址：src/main/java/com/proxy/demo01/Host.java
代码：
package com.proxy.demo01;
/*
房东
*/
public class Host implements Rent{
public void rent(){
System.out.println("房东要出租房子");
}
}
3.Proxy . java 中介即代理角色
地址：src/main/java/com/proxy/demo01/Proxy.java
代码：
package com.proxy.demo01;
/**
* 代理：帮房东出租房子
*/
public class Proxy implements Rent {
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
@Override
public void rent() {
//看房
seeHouse();
//租房
host.rent();
//签合同
contract();
//收中介费
fare();
}
//看房，中介可以做，房东不可以
public void seeHouse() {
System.out.println("中介带你看房");
}
//签合同，中介可以做，房东不可以
public void contract(){
System.out.println("签合同");
}
//签合同
public void fare(){
System.out.println("收中介费");
}
}
4.Client . java 即客户
地址：src/main/java/com/proxy/demo01/Client.java
代码：
package com.proxy.demo01;
/**
* 租房
*/
public class Client {
public static void main(String[] args) {
//房东要租房子
Host host = new Host();
//代理，中介帮房东租房子，但是代理有自己的单独操作
Proxy proxy = new Proxy(host);
//你不用面对房东，直接找中介即可
proxy.rent();
}
}
分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式，程序源自于生活，所以学编程的人，一般能够更加抽象的看待生活中发生的事情。
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~
- 我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !
2. 加深理解
1. 创建一个抽象角色实现增删改查
地址：src/main/java/com/proxy/demo02/UserService.java
代码：
package com.proxy.demo02;
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
2. 真实角色实现抽象类
地址：src/main/java/com/proxy/demo02/UserServiceImpl.java
代码：
package com.proxy.demo02;
//真是对象
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("修改了一个用户");
}
@Override
public void query() {
System.out.println("查询了一个用户");
}
}
3. 新增日志功能，添加代理类
-
需求来了，现在我们需要增加一个日志功能，怎么实现！
-
思路1 ：在实现类上增加代码 【麻烦！】
-
思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！
地址：src/main/java/com/proxy/demo02/UserServiceProxy.java
代码：
package com.proxy.demo02;
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
@Override
public void add() {
log("add");
userService.add();
}
@Override
public void delete() {
log("delete");
userService.delete();
}
@Override
public void update() {
log("update");
userService.update();
}
@Override
public void query() {
log("query");
userService.query();
}
//日志方法
public void log(String msg) {
System.out.println("使用了" + msg + "方法");
}
}
4. 测试
地址：src/main/java/com/proxy/demo02/Client.java
代码：
package com.proxy.demo02;
public class Client {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
UserServiceProxy userServiceProxy = new UserServiceProxy();
userServiceProxy.setUserService(userService);
userServiceProxy.update();
}
}
OK，到了现在代理模式大家应该都没有什么问题了，重点大家需要理解其中的思想；
我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想
3.聊聊AOP：纵向开发，横向开发
2. 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的！
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 — JDK动态代理【我们在这里使用】
- 基于类：cglib
- java字节码实现：javassist
JDK的动态代理需要了解两个类
- Proxy：代理；
- InvocationHandler：调用处理程序。
1. 【InvocationHandler：调用处理程序】
Object invoke(Object proxy, 方法 method, Object[] args)；
//参数
//proxy - 调用该方法的代理实例
//method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。
//args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。
2. 【Proxy : 代理】
//生成代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
3. 代码实现
1. Rent . java 租房接口类即抽象角色
package com.proxy.demo03;
/*
租房接口类
*/
public interface Rent {
public void rent();
}
2.Host . java房东 即真实角色
package com.proxy.demo03;
import com.proxy.demo03.Rent;
/*
房东
*/
public class Host implements Rent {
public void rent(){
System.out.println("房东要出租房子");
}
}
3.ProxyInvocationHandler. java 即代理角色
package com.proxy.demo03;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理生成类
* 会用这个类，自动生成代理类
*/
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到代理类,重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), rent.getClass().getInterfaces(), this);
}
// proxy : 代理类 method : 代理类的调用处理程序的方法对象.
// 处理代理实例上的方法调用并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHose();
fee();
//核心：本质利用反射实现！
Object invoke = method.invoke(rent, args);
return invoke;
}
public void seeHose(){
System.out.println("中介带着看房子！");
}
public void fee(){
System.out.println("中介收取费用！");
}
}
4.Client . java测试
package com.proxy.demo03;
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理角色：现在没有
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色，来处理我们要调用的接口对象
pih.setRent(host);
Rent proxy = (Rent) pih.getProxy();
proxy.rent();
}
}
结果：
中介带着看房子！
中介收取费用！
房东要出租房子
进程已结束，退出代码为 0
核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！
4. 深化理解
我们来使用动态代理实现代理我们后面写的UserService！
我们也可以编写一个通用的动态代理实现的类！所有的代理对象设置为Object即可！
1. ProxyInvocationHandler.Java生成代理类
package com.proxy.demo04;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理生成类
* 会用这个类，自动生成代理类
*/
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成得到代理类,重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
// proxy : 代理类 method : 代理类的调用处理程序的方法对象.
// 处理代理实例上的方法调用并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
//核心：本质利用反射实现！
Object invoke = method.invoke(target, args);
return invoke;
}
public void log(String methodName){
System.out.println("执行了"+methodName+"方法");
}
}
2. Client.Java测试
package com.proxy.demo04;
import com.proxy.demo02.UserService;
import com.proxy.demo02.UserServiceImpl;
public class Client {
public static void main(String[] args) {
//真实角色，实现类
UserServiceImpl userService = new UserServiceImpl();
//代理角色，不存在
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//设置要代理的对象，实现类
pih.setTarget(userService);
//动态生成代理类,接口类
UserService proxy =(UserService) pih.getProxy();
proxy.add();
}
}
结果：
执行了add方法
增加了一个用户
进程已结束，退出代码为 0
5. 动态代理的好处
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共角色就交给代理角色！实现了业务的分工！
- 公共业务发生扩展的时候，方便集中管理！
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！
九、AOP
1. 什么是aop
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
2.Aop在Spring中的作用
提供声明式事务；允许用户自定义切面
以下名词需要了解下：
-
横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
-
切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
-
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
-
目标（Target）：被通知对象。
-
代理（Proxy）：向目标对象应用通知之后创建的对象。
-
切入点（PointCut）：切面通知 执行的 “地点”的定义。
-
连接点（JointPoint）：与切入点匹配的执行点。
SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:
3. 使用Spring实现Aop
1. pom.xml导入AOP依赖
【重点】使用AOP织入，需要导入一个依赖包！
<dependencies>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.8.RC1</version>
</dependency>
</dependencies>
2. 方式一： 使用Spring的API接口【主要是SpringAPI接口实现】
1. 接口类
地址：src/main/java/com/aop/service/UserService.java
代码：
package com.aop.service;
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
2. 接口实现类
地址：src/main/java/com/aop/service/UserServiceImpl.java
代码：
package com.aop.service;
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("修改了一个用户");
}
@Override
public void select() {
System.out.println("查询了一个用户");
}
}
3. MethodBeforeAdvice 前置增强
地址：src/main/java/com/aop/log/Log.java
代码：
package com.aop.log;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
//method:要执行的目标对象的方法
//objects：参数
//target:目标对象
public class Log implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
4. AfterReturningAdvice 后置增强
地址：src/main/java/com/aop/log/AfterLog.java
代码：
package com.aop.log;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
public class AfterLog implements AfterReturningAdvice {
//returnValue:返回值
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了" + method.getName() + "返回结果为：" + returnValue);
}
}
5.applicationContext.xml Spring文件注册
地址：src/main/resources/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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册bean-->
<bean id="userService" class="com.aop.service.UserServiceImpl"/>
<bean id="log" class="com.aop.log.Log"/>
<bean id="afterLog" class="com.aop.log.AfterLog"/>
<!--方式一：使用原生的Spring api接口-->
<!-- 配置aop:需要导入aop的约束-->
<aop:config>
<!--切入点 expression:表达式 execution(要执行的位置)-->
<aop:pointcut id="pointcut" expression="execution(* com.aop.service.UserServiceImpl.*(..))"/>
<!--执行环绕增加-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
6. 测试
import com.aop.service.UserService;
import com.aop.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理，d代理的是接口
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
结果：
com.aop.service.UserServiceImpl的add被执行了
增加了一个用户
执行了add返回结果为：null
进程已结束，退出代码为 0
Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .
Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .
3.方式二： 自定义类来实现AOP【主要是切面定义】
- 目标业务类不变依旧是userServiceImpl
1.自定义切入类
地址：src/main/java/com/aop/diy/DiyPointCut.java
代码：
package com.aop.diy;
public class DiyPointCut {
public void before() {
System.out.println("方法执行前");
}
public void after() {
System.out.println("方法执行后");
}
}
2.applicationContext.xml Spring文件注册
地址：src/main/resources/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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册bean-->
<bean id="userService" class="com.aop.service.UserServiceImpl"/>
<bean id="log" class="com.aop.log.Log"/>
<bean id="afterLog" class="com.aop.log.AfterLog"/>
<!--方式二：自定义类-->
<bean id="diy" class="com.aop.diy.DiyPointCut"/>
<aop:config>
<!--自动以切面，ref要引入的类-->
<aop:aspect ref="diy">
<aop:pointcut id="point" expression="execution(* com.aop.service.UserServiceImpl.*(..))"/>
<!--通知-->
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
</beans>
3.测试
import com.aop.service.UserService;
import com.aop.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理，d代理的是接口
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
结果：
方法执行前
增加了一个用户
方法执行后
进程已结束，退出代码为 0
4. 方式三：使用注解实现AOP
1.注解实现的增强类
package com.aop.diy;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
//使用注解实现aop
@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
@Before("execution(* com.aop.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("方法执行前");
}
@After("execution(* com.aop.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("方法执行后");
}
//在环绕增强中，我们可以给定一个参数，代表我们要获取处理的切入点
@Around("execution(* com.aop.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint jp)throws Throwable{
System.out.println("环绕前");
Signature signature = jp.getSignature();//获得签名
System.out.println("signature"+signature);
//执行方法
Object proceed = jp.proceed();
System.out.println("环绕后");
System.out.println(proceed);
}
}
2.在Spring配置文件中，注册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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 注册bean-->
<bean id="userService" class="com.aop.service.UserServiceImpl"/>
<bean id="log" class="com.aop.log.Log"/>
<bean id="afterLog" class="com.aop.log.AfterLog"/>
<!--方式三：注解-->
<bean id="anntationPointCut" class="com.aop.diy.AnnotationPointCut"/>
<aop:aspectj-autoproxy/>
</beans>
3. 测试
import com.aop.service.UserService;
import com.aop.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理，d代理的是接口
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
结果：
环绕前
signaturevoid com.aop.service.UserService.add()
方法执行前
增加了一个用户
方法执行后
环绕后
null
进程已结束，退出代码为 0
aop:aspectj-autoproxy：说明
通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了
<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。
十、整合Mybatis
步骤：
1. 导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关
- aop织入器
- mybatis-spring整合包【重点】在此还导入了lombok包。
- 配置Maven静态资源过滤问题！
pom.xml配置
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-study</artifactId>
<groupId>com.xxx</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.mybatis</groupId>
<artifactId>spring-10-mybatis</artifactId>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<!--重点：导入依赖-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!--Spring操作数据库的话，还需要一个spring-jdbc
-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
</dependency>
</dependencies>
<!--重点：资源绑定-->
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
2. 编写配置文件
3. 测试
1. 回忆mybatis
文档路径：https://mybatis.org/mybatis-3/zh/index.html
1. 实体类
地址：src/main/java/com/mybatis/pojo/User.java
代码：
package com.mybatis.pojo;
import lombok.Data;
@Data
public class User {
private int id;
private String name;
private String pwd;
}
2. 核心配置文件
地址：src/main/resources/mybatis-config.xml
代码：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--定义别名-->
<typeAliases>
<package name="com.mybatis.pojo"/>
</typeAliases>
<!--环境 default 默认当前环境是development-->
<environments default="development">
<!--development 开发环境-->
<environment id="development">
<!--事务管理，默认使用jdbc-->
<transactionManager type="JDBC"/>
<!--数据源 汇集-->
<dataSource type="POOLED">
<!-- 驱动 ${driver} com.mysql.jdbc.Driver -->
<property name="driver" value="com.mysql.jdbc.Driver"/>
<!-- 链接地址 ${url} jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8 -->
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8"/>
<!--用户名 ${username} root -->
<property name="username" value="root"/>
<!--秘密 ${password} root-->
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper class="com.mybatis.mapper.UserMapper"/>
</mappers>
</configuration>
3. 接口
地址：src/main/java/com/mybatis/mapper/UserMapper.java
代码：
package com.mybatis.mapper;
import com.mybatis.pojo.User;
import java.util.List;
public interface UserMapper {
public List<User> selectUser();
}
4. Mapper.xml
地址：src/main/java/com/mybatis/mapper/UserMapper.xml
代码：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mybatis.mapper.UserMapper">
<!--sql-->
<select id="selectUser" resultType="user">
select * from mybatis.user
</select>
</mapper>
5. 测试
import com.mybatis.mapper.UserMapper;
import com.mybatis.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void getUser() throws IOException {
//获取数据库链接资源
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
//获取mapper接口类
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//查询接口
List<User> userList = mapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
}
结果：
User(id=1, name=ss, pwd=123456)
User(id=2, name=aaa, pwd=bbb)
User(id=3, name=ff, pwd=123456)
User(id=4, name=gg, pwd=123456)
User(id=5, name=ww, pwd=123456)
进程已结束，退出代码为 0
2.Mybatis-Spring
文档：http://mybatis.org/spring/zh/index.html
1.整合mybatis-spirng 方式一
1. pom.依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-study</artifactId>
<groupId>com.xxx</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.mybatis</groupId>
<artifactId>spring-10-mybatis</artifactId>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<!--重点：导入依赖-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!--Spring操作数据库的话，还需要一个spring-jdbc
-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
</dependency>
</dependencies>
<!--重点：资源绑定-->
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
2. 实体类
路径：src/main/java/com/mybatis/pojo/User.java
代码：
package com.mybatis.pojo;
import lombok.Data;
@Data
public class User {
private int id;
private String name;
private String pwd;
}
3.MAPPER接口类
地址：src/main/java/com/mybatis/mapper/UserMapper.java
代码：
package com.mybatis.mapper;
import com.mybatis.pojo.User;
import java.util.List;
public interface UserMapper {
public List<User> selectUser();
}
3.MAPPER.xml
地址：src/main/java/com/mybatis/mapper/UserMapper.xml
代码
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mybatis.mapper.UserMapper">
<!--sql-->
<select id="selectUser" resultType="user">
select * from mybatis.user
</select>
</mapper>
4.创建数据源配置文件
地址：src/main/resources/spring-dao.xml
1. 引入Spring配置文件spring-dao.xml
<?xml version="1.0" encoding="GBK"?>
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
</beans>
2.配置数据源替换mybaits的数据源
<!--DataSource 使用spring的数据源替换mybatis的配置 c3p0 dbcp druid-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
3.配置SqlSessionFactory，关联MyBatis
<!-- sqlSessionFactory-->
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/mybatis/mapper/*.xml"/>
</bean>
4.注册sqlSessionTemplate，关联sqlSessionFactory
<!--SqlSessionTemplate:就是我们的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能用构造器注入sqlSessionFactory，因为他没有set方法-->
<constructor-arg index="0" ref="SqlSessionFactory"/>
</bean>
5. 完整配置代码
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
<!--DataSource 使用spring的数据源替换mybatis的配置 c3p0 dbcp druid-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- sqlSessionFactory-->
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/mybatis/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能用构造器注入sqlSessionFactory，因为他没有set方法-->
<constructor-arg index="0" ref="SqlSessionFactory"/>
</bean>
</beans>
5. 给接口加实现类
需要UserMapper接口的UserMapperImpl 实现类，私有化sqlSessionTemplate
地址：src/main/java/com/mybatis/mapper/UserMapperImpl.java
代码：
package com.mybatis.mapper;
import com.mybatis.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
public class UserMapperImpl implements UserMapper {
//我们的所有操作都是用sqlSession来执行，在原来，现在都是用SqlSessionTemplate;
private SqlSessionTemplate sqlSession;
public void setSqlSession(SqlSessionTemplate sqlSession) {
this.sqlSession = sqlSession;
}
@Override
public List<User> selectUser() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.selectUser();
return userList;
}
}
6. 实现类注册
地址：src/main/resources/spring-dao.xml
代码：
<bean id="UserMapperImpl" class="com.mybatis.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
完整代码
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
<!--DataSource 使用spring的数据源替换mybatis的配置 c3p0 dbcp druid-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/mybatis/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能用构造器注入sqlSessionFactory，因为他没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<bean id="UserMapperImpl" class="com.mybatis.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
7. mybatis-config.xml配置文件修改
地址：src/main/resources/mybatis-config.xml
代码：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<package name="com.mybatis.pojo"/>
</typeAliases>
</configuration>
8.测试
import com.mybatis.mapper.UserMapper;
import com.mybatis.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void selectUser(){
ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
List<User> userList = userMapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
结果：
User(id=1, name=ss, pwd=123456)
User(id=2, name=aaa, pwd=bbb)
User(id=3, name=ff, pwd=123456)
User(id=4, name=gg, pwd=123456)
User(id=5, name=ww, pwd=123456)
进程已结束，退出代码为 0
9. 整合配置
- 新建
src/main/resources/applicationContext.xml文件 - 引入
spring-dao.xml，实现类注册单独拿出来放到applicationContext.xml统一管理
- applicationContext.xml
- 路径：
src/main/resources/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-dao-->
<import resource="spring-dao.xml"/>
<!--实现类注册-->
<bean id="UserMapperImpl" class="com.mybatis.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
- spring-dao.xml
- 路径：
src/main/resources/spring-dao.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
<!--DataSource 使用spring的数据源替换mybatis的配置 c3p0 dbcp druid-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- sqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/mybatis/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能用构造器注入sqlSessionFactory，因为他没有set方法-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
</beans>
- 测试：
import com.mybatis.mapper.UserMapper;
import com.mybatis.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void getUser() throws IOException {
/* String mybatis = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(mybatis);
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = build.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();*/
}
@Test
public void test2() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("UserMapperImpl", UserMapper.class);
List<User> userList = userMapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
结果：
1.整合mybatis-spirng 方式二
1. 实现
1. 添加方式二实现类
地址：src/main/java/com/mybatis/mapper/UserMapperImpl2.java
代码：
package com.mybatis.mapper;
import com.mybatis.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
@Override
public List<User> selectUser() {
SqlSession sqlSession = getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.selectUser();
return userList;
}
}
2. 注入到Spring配置文件中。
地址：src/main/resources/applicationContext.xml
代码：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
<import resource="spring-dao.xml"/>
<!-- 注册-->
<bean id="userMapper" class="com.mybatis.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
<bean id="userMapper2" class="com.mybatis.mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="SqlSessionFactory"/>
</bean>
</beans>
3.测试
import com.mybatis.mapper.UserMapper;
import com.mybatis.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void selectUser(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("userMapper2", UserMapper.class);
List<User> userList = userMapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
结果：
User(id=1, name=ss, pwd=123456)
User(id=2, name=aaa, pwd=bbb)
User(id=3, name=ff, pwd=123456)
User(id=4, name=gg, pwd=123456)
User(id=5, name=ww, pwd=123456)
进程已结束，退出代码为 0
十一、Spring配置声明事务注入
1. 回顾事务
- 把一组业务当成一个业务来做；要么都成功，要么都失败！
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
- 确保完整性和一致性。
事务ACID原则：
- 原子性（atomicity）
- 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
- 一致性（consistency）
- 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
- 隔离性（isolation）
- 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
- 持久性（durability）
- 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。
2.配置环境
1.新建空model：transaction
2. 导入依赖
地址：pom.xml
代码：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-study</artifactId>
<groupId>com.xxx</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.transaction</groupId>
<artifactId>spring-11-transaction</artifactId>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
</properties>
<!--重点：导入依赖-->
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!--Spring操作数据库的话，还需要一个spring-jdbc
-->
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
</dependency>
</dependencies>
<!--重点：资源绑定-->
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
3. 配置实体类
地址：src/main/java/com/transaction/pojo/User.java
代码：
package com.transaction.pojo;
import lombok.Data;
@Data
public class User {
private int id;
private String name;
private String pwd;
}
4. 新建接口类
地址：src/main/java/com/transaction/mapper/UserMapper.java
代码：
package com.transaction.mapper;
import com.transaction.pojo.User;
import java.util.List;
public interface UserMapper {
public List<User> selectUser();
}
5. 创建mybatis-config.xml文件
地址：src/main/resources/mybatis-config.xml
代码：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--定义别名-->
<typeAliases>
<package name="com.transaction.pojo"/>
</typeAliases>
<!--配置-->
<!-- <settings>
<setting name="" value=""/>
</settings>-->
</configuration>
6.整合spring数据库链接配置文件
地址：src/main/resources/spring-dao.xml
代码：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
<!--DataSource 使用spring的数据源替换mybatis的配置 c3p0 dbcp druid-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- sqlSessionFactory-->
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/transaction/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能用构造器注入sqlSessionFactory，因为他没有set方法-->
<constructor-arg index="0" ref="SqlSessionFactory"/>
</bean>
</beans>
7.Mapper.xml
地址：src/main/java/com/transaction/mapper/UserMapper.xml
代码：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.transaction.mapper.UserMapper">
<!--sql-->
<select id="selectUser" resultType="user">
select * from mybatis.user
</select>
</mapper>
8. 实现类
地址：src/main/java/com/transaction/mapper/UserMapperImpl.java
代码：
package com.transaction.mapper;
import com.transaction.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> selectUser() {
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
List<User> userList = mapper.selectUser();
return userList;
}
}
9. 配置bean
地址：src/main/resources/applicationContext.xml
代码：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
<!--引入spring数据库配置-->
<import resource="spring-dao.xml"/>
<!--配置bean-->
<bean id="UserMapper" class="com.transaction.mapper.UserMapperImpl">
<property name="sqlSessionFactory" ref="SqlSessionFactory"/>
</bean>
</beans>
10.测试
import com.transaction.mapper.UserMapper;
import com.transaction.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class MyTest {
@Test
public void selectUser() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("UserMapper", UserMapper.class);
List<User> userList = userMapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
结果：
User(id=1, name=ss, pwd=123456)
User(id=2, name=aaa, pwd=bbb)
User(id=3, name=ff, pwd=123456)
User(id=4, name=gg, pwd=123456)
User(id=5, name=ww, pwd=123456)
进程已结束，退出代码为 0
3. Spring中的事务管理
Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。
1.声明式事务管理
- 一般情况下比编程式事务好用。
- 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
- 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
2. 编程式事务管理
- 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
- 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码
3. aop方式配置事务
1. 头文件导入约束tx和aop
路径：src/main/resources/spring-dao.xml
代码：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
2. JDBC事务
路径：src/main/resources/spring-dao.xml
代码：
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- <constructor-arg ref="datasource"/>-->
<property name="dataSource" ref="datasource"/>
</bean>
3. 配置好事务管理器后我们需要去配置事务的通知
路径：src/main/resources/spring-dao.xml
代码：
<!--结合AOP实现事务的-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给那些方法配置事务-->
<!--配置事务的传播特性： propagation="REQUIRED" -->
<tx:attributes>
<!--指定某些方法支持事务-->
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="query" read-only="true"/>
<!--所有的都支持-->
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
4.配置事务切入点
路径：src/main/resources/spring-dao.xml
代码：
<!-- 配置事务切入点-->
<aop:config>
<!--指定切入点位置-->
<aop:pointcut id="txPointCut" expression="execution(* com.transaction.mapper.*.*(..))"/>
<!--给切入点配置事务-->
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
5. 整体代码
路径：src/main/resources/spring-dao.xml
代码：
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!--DataSource 使用spring的数据源替换mybatis的配置 c3p0 dbcp druid-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=TRUE&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!-- sqlSessionFactory-->
<bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource"/>
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/transaction/mapper/*.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能用构造器注入sqlSessionFactory，因为他没有set方法-->
<constructor-arg index="0" ref="SqlSessionFactory"/>
</bean>
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- <constructor-arg ref="datasource"/>-->
<property name="dataSource" ref="datasource"/>
</bean>
<!--结合AOP实现事务的-->
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给那些方法配置事务-->
<!--配置事务的传播特性： propagation="REQUIRED" -->
<tx:attributes>
<!--指定某些方法支持事务-->
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="query" read-only="true"/>
<!--所有的都支持-->
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 配置事务切入点-->
<aop:config>
<!--指定切入点位置-->
<aop:pointcut id="txPointCut" expression="execution(* com.transaction.mapper.*.*(..))"/>
<!--给切入点配置事务-->
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
</beans>
6. 接口实现类测试
地址：src/main/java/com/transaction/mapper/UserMapperImpl.java
代码：
package com.transaction.mapper;
import com.transaction.pojo.User;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> selectUser() {
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
User user = new User(6, "张三三", "123123");
mapper.addUser(user);
mapper.delUser(5);
List<User> userList = mapper.selectUser();
return userList;
}
@Override
public int addUser(User user) {
return getSqlSession().getMapper(UserMapper.class).addUser(user);
}
@Override
public int delUser(int id) {
return getSqlSession().getMapper(UserMapper.class).delUser(1);
}
}
7. 测试
测试点：先调用添加，再调用删除，测试删除用户sql故意写错，看是否会添加成功。
- 例如：src/main/java/com/transaction/mapper/UserMapper.xml文件里面的
delete from mybatis.user where id = #{id}可以写错为deletes from mybatis.user where id = #{id} - 如果添加执行成功：说明没有执行事务
- 如果添加执行失败：说明执行了事务，报错会回滚事务。
import com.transaction.mapper.UserMapper;
import com.transaction.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class MyTest {
@Test
public void selectUser() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = context.getBean("UserMapper", UserMapper.class);
List<User> userList = userMapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
结果：
User(id=1, name=ss, pwd=123456)
User(id=2, name=aaa, pwd=bbb)
User(id=3, name=ff, pwd=123456)
User(id=4, name=gg, pwd=123456)
User(id=6, name=张三三, pwd=123123)
进程已结束，退出代码为 0
进程已结束，退出代码为 0
思考：为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况；
- 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
- 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
