Spring学习笔记
文章目录
前言
本内容为本人在哔站学习由notepad++实时记录,没有经过idea编译,直接贴入本博客以防止丢失,如有错误之处,还望指正,谢谢大家😅😅😅
1.Spring是什么
1.1简介:
- spring:春天------> 给软件行业带来了春天
- 2002年:首次推出Spring框架的雏形,interface21框架
- Spring宽假即以interface21为基础,经过重新设计,并不断丰富其内涵,2004年发布1.0正式版本。
- Spring理念:是现有技术更加容易使用,本身是一个大杂烩,整合了现有的技术框架。
- Rod Johnson
- SSH :Struct2 Spring Hibernate
- SSM :SpringMVC Spring Mybatis
1.2优点
- Spring是一个免费的开源的框架(容器)
- Spring是一个轻量级的 非入侵式的框架
- 控制反转IOC 面向切面编程AOP
- 支持事务的处理,对整合的支持
== 总结:Spring就是一个轻量级的控制反转IOC 和面向切面AOP的框架
1.3组成
1.4拓展
在Spring的官网有这个介绍:现代化的Java开发,就是基于Sping的开发
- Spring Boot
- 一个快速开发的脚手架
- 计划于SpringBoot可以快速开发单个微服务
- 约定大于配置
- Spring Cloud
- SpingCloud是基于SpringBoot实现的
因为现在大多数公司在使用SpringBoot进行快速开发,学习SpringBoot的前提,需要完全掌握Spring及SpringMVC 承上启下的作用。
- SpingCloud是基于SpringBoot实现的
弊端:发展了太久之后,违背了原来的设计理念,配置十分繁琐,配置地狱。
2.IOC理论推导
1.UserDao接口
2.UserDaoImpl实现类
3.UserService业务接口
4.UserService业务实现类
导依赖包 spring-webmvc
public interface UserDao{
void getUser();
}
public class UserDaoImpl implements UserDao{
public void void getUser(){
System.out.println("默认获取用户的数据");
}
}
public interface UserService{
void getUser();
}
public class UserServiceImpl implements UserService{
//private UserDao userDao = new UesrDaoImpl(); 本来是写死的,如果用户需求变了 ,此业务层的UserDaoImpl()也需要修改,为相应的业务实现方法,但是用了下面的set注入之后,就不需要在业层修改代码了,直接在Test类的用户userService调用那传入UserDaoImpl()业务,这个UserDaoImpl()业务相当于参数传给set,然后给了ServiceImpl层中的private UserDao userDao了,而不是一开始直接在此处new,UserDaoImpl() 变了,ServiceImpl层就得变,用set就不需要了,相当于Service代码不需要修改了
- 本质就是把要在因为需求而导致修改ServiceImpl代码工作转移到去Test中具体实现时传入相应的业务就行,不需要修改Service了。
private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
public void getUser(){
userDao.getUser();
}
}
public class MyTest{
public static void main(String[] args){
//用户实际调用的是业务层,dao层他们不需要接触
//UserService userService = new UserServiceImpl();
userService.setUserDao(new UserDaoXXXServerImpl());
userService.getUser();
}
}
在之前的业务中,用户的需求可能会影响原来的代码,我们需要根据需求去修改原代码,如果程序的代码量十分大,修改的一次的成本代价非常昂贵。
我们通过使用Set接口去实现,发生了革命性的变化。
private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
之前,程序是主动创建对象,控制权在程序员手上
使用了 set注入后,程序不再具有主动性,而是变成了被动的接受对象。
这种思想,从本质上解决了问题,我们程序员就不用再去管理对象的创建了。系统的耦合性大大降低,可以专注在业务的实现上,这是IOC的原型。
3.helloSpring
package com.kuang.pojo;
public class User {
private String name;
// public User() {
// System.out.println("User的无参构造");
// }
public User(String name){
this.name= name;
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);
}
}
4.IOC创建对象的方式
1.使用无参构造方式创建
2.假设我们要是由有参构造方式创建。
package com.kuang.pojo;
public class UserTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
System.out.println(user);
user.show();
}
}
构造的方式注入
beans.xml文件中的配置
1.默认调用无参
<bean id="user" class="com.kuang.pojo.User">
<property name="name" value="liyanghua"></property>
</bean>
2.有参调用方式一:通过下标赋值
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg index="0" value="通过下标赋值创建"></constructor-arg>
</bean>
3.有参调用方式二:通过类型,不建议使用
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg type="java.lang.String" value="通过类型创建方式"></constructor-arg>
</bean>
4。有参调用方式二:通过参数名创建
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg name="name" value="通过参数名创建"></constructor-arg>
</bean>
总结,在配置文件加载的时候,容器中管理的对象就已经初始化了。
5.Spring配置
5.1 别名
如果添加了别名,我们即可通过使用别名获取到这个对象。
//配置文件中
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg name="name" value="通过参数名创建"></constructor-arg>
</bean>
<alias name="user" alias="userAlias"></alias>
//测试类中
User user = (User) context.getBean("user");
User userAlias = (User) context.getBean("userAlias");
5.2 bean配置
id:bean的唯一标识符,也就是相当于我们学的对象名
class:bean对象对应的全限定名 包名+类型
name:也是别名,而且name可以取多个别名
<bean id="user" class="com.kuang.pojo.User" name="user2 u2,user3;u3">
<property name="name" value="hhh"></property>
</bean>
User u2 = (User) context.getBean("u2");
User user3 = (User) context.getBean("user3");
5.3 import
import,一般用于团队开发使用,它可以将多个配置文件,导入合并为一个
假设,现在项目中有多个人开发,这三个人负责不同类的开发,不同的类型需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的
- 张三
- 李四
- 王五
- applicationContext.xml
<import resource="beans.xml"></import>
<import resource="beans2.xml"></import>
<import resource="beans3.xml"></import>
使用的时候,直接使用总的配置就可以了
6.依赖注入
6.1 构造器注入
前面已经学过
6.2 set方式注入(重点)
-
依赖注入:Set注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中的所有属性,由容器来注入
【环境搭建】
1.复杂类型
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
2.真实测试对象
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 into;
}
3.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="student" class="com.kuang.pojo.Student">
<!-- 第一种:普通值注入-->
<property name="name" value="liyanghua"></property>
</bean>
</beans>
4.测试类
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());
}
}
5.完善注册信息
<bean id="address" class="com.kuang.pojo.Address"></bean>
<bean id="student" class="com.kuang.pojo.Student">
<!-- 第一种:普通值注入-->
<property name="name" value="liyanghua"></property>
<!-- 第一种:Bean注入,ref-->
<property name="address" ref="address"></property>
<!-- 数组注入,ref-->
<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>
</list>
</property>
<!--map-->
<property name="card">
<map>
<entry key="身份证" value="1231546446"></entry>
<entry key="银行卡" value="333336511"></entry>
</map>
</property>
<!-- Set-->
<property name="games">
<set>
<value>LOL</value>
<value>COC</value>
<value>HPH</value>
</set>
</property>
<!-- null-->
<property name="wife">
<null></null>
</property>
<!-- Properties-->
<property name="into">
<props>
<prop key="学号">2050511111</prop>
<prop key="性别">男</prop>
<prop key="姓名">法外狂徒</prop>
</props>
</property>
</bean>
6.3 拓展方式注入
官方文档
使用
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<!-- 引入p命名空间-->
xmlns:p="http://www.springframework.org/schema/p"
<!-- 引入c命名空间-->
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- p命名空间注入,可以直接注入属性的值:property -->
<bean id="user" class="com.kuang.pojo.User" p:name="liyanghua" p:age="18"></bean>
<!-- c命名空间注入,通过构造器注入;construct-args-->
<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="libai"></bean>
</beans>
测试
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = (User) context.getBean("user2");
System.out.println(user.toString());
}
注意点: p命名和c命名空间不能直接使用,需要导入xml约束
<!-- 引入p命名空间-->
xmlns:p="http://www.springframework.org/schema/p"
<!-- 引入c命名空间-->
xmlns:c="http://www.springframework.org/schema/c"
6.4 bean的作用域
1.单例模式(Spring默认机制)
2.原型模式:每次从容器中get的时候,都会产生一个新对象
3.其余的request,session,application这些之只能在web开发中使用到。
7.Bean的自动装配
- 自动装配是满足bean依赖的一种方式
- Spring会在上下文中自动寻找,并自动给bean装配属性
在Spring中由三种装配的方式
1.在xml中显示的配置
2.在java中显示装配
3.隐式的自动装配bean (重要)
7.1测试
1.环境搭建
- 一个人有两只宠物
<bean id="cat" class="com.kuang.pojo.Cat"></bean>
<bean id="dog" class="com.kuang.pojo.Dog"></bean>
<bean id="people" class="com.kuang.pojo.People">
<property name="name" value="李白"></property>
<property name="dog" ref="dog"></property>
<property name="cat" ref="cat"></property>
</bean>
7.2 byName自动装配
<bean id="cat" class="com.kuang.pojo.Cat"></bean>
<bean id="dog" class="com.kuang.pojo.Dog"></bean>
<!-- byName:会自动在容器上下文中查找,和自己对象set方法后面值对应的beanid-->
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
<property name="name" value="李牧"></property>
</bean>
7.3 byType自动装配
<bean class="com.kuang.pojo.Cat"></bean>
<bean id="dog" class="com.kuang.pojo.Dog"></bean>
<!-- byType:会自动在容器上下文中查找,和自己对象属性类型相同的bean,可以省略id-->
<bean id="people" class="com.kuang.pojo.People" autowire="byType">
<property name="name" value="李牧"></property>
</bean>
小结:
- byName的时候,需要保证所有的bean的id唯一,并且这个bean需要和自动注入的属性的set方法值一致
- byType的时候,需要保证所有的bean的Class唯一,并且这个bean需要和自动注入的属性的类型一致
7.4使用注解自动装配
jdk1.5支持的注解,Spring2.5就支持注解了
要使用注解须知:
1.导入约束 context约束
2.配置注解的支持 context:annotation-config
<?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>
@Autowired
直接在属性上使用即可。也可以在set方式上使用
使用Autowired 我们可以不用编写Set方法了,前提是这个自动装配的属性在IOC(Spring)容器中存在,且符合名字byname。
科普:
@Nullable 字段标记了这个注解,说明这个字段可以为null
public @interface Autowired{
boolean required() default true;
}
测试代码
public class People {
//如果显示定义了Autowired的required属性为false,说明这个属性可以为null,否则不允许
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解{@Autowired}完成的时候,我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用,指定一个唯一的bean对象注入,
类似@Autowired的有JAVA的@Resource,@Resource(name=“cat22”);或者当bean中唯会先去找id的名,找不到就找类型 然后装配注入,用的少。
复杂环境的beans.xml
<!--开启注解的支持-->
<context:annotation-config></context:annotation-config>
<bean id="cat11" class="com.kuang.pojo.Cat"></bean>
<bean id="cat22" class="com.kuang.pojo.Cat"></bean>
<bean id="dog11" class="com.kuang.pojo.Dog"></bean>
<bean id="dog22" class="com.kuang.pojo.Dog"></bean>
<bean id="people" class="com.kuang.pojo.People"></bean>
使用@Qualifier的测试
public class People {
//如果显示定义了Autowired的required属性为false,说明这个属性可以为null,否则不允许
@Autowired(required = false)
@Qualifier(value = "cat22")
private Cat cat;
@Autowired
@Qualifier(value = "dog22")
private Dog dog;
private String name;
}
@Resource注解
public class People {
//如果显示定义了Autowired的required属性为false,说明这个属性可以为null,否则不允许
@Resource(name="cat22")
private Cat cat;
@Resource
private Dog dog;
private String name;
}
小结:
@Resource和 @Autowired的区别
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired通过bytype的方式实现,而且要求这个对象必须存在(常用)
- @Resource默认通过byname的方式实现,如果找不到名字,则通过bytype实现,如果两个都找不到的情况下,就报错。(常用)
- 执行顺序不同 :@Autowired通过bytype的方式实现 @Resource默认通过byname的方式实现
8.使用注解开发
1.bean
我们之前 都是使用 bean 的标签进行bean注入,但是实际开发中,我们一般都会使用注解!
引入context
<?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
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
</beans>
配置扫描哪些包下的注解
开启扫描
<context:component-scan base-package="com.kuang.pojo"/>
在指定包下编写类,增加注解
@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
public String name = "秦疆";
}
@Test
public void test(){
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("beans.xml");
User user = (User) applicationContext.getBean("user");
System.out.println(user.name);
}
2.属性如何注入
可以不用提供set方法,直接在直接名上添加@value(“值”)
@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
@Value("李商隐")
// 相当于配置文件中 <property name="name" value="李商隐"/>
public String name;
}
如果提供了set方法,在set方法上添加@value(“值”);
@Component("user")
public class User {
public String name;
@Value("李白")
public void setName(String name) {
this.name = name;
}
}
3.衍生的注解
@Component三个衍生注解
在web开发中,按照mvc三层架构分层。功能一样,目前使用哪一个功能都一样。
@Controller:--------controller层
@Service:-----------service层
@Repository:-------dao层
写上这些注解,就相当于将这个类交给Spring管理装配了!
这四个注解的功能都是一样的,都是代表将某个类注册到Spring中,装配Bean。
4.自动装配
如上一部分
5.作用域
@scope
singleton:默认的,Spring会采用单例模式创建这个对象。关闭工厂 ,所有的对象都会销毁。
prototype:多例模式。关闭工厂 ,所有的对象不会销毁。内部的垃圾回收机制会回收
@Controller("user")
@Scope("prototype")
public class User {
@Value("秦疆")
public String name;
}
6.小结
XML与注解:
-
XML可以适用任何场景 ,结构清晰,维护方便
-
注解不是自己提供的类使用不了,开发简单方便,维护相对复杂
xml与注解整合开发 :推荐最佳实践
-
xml管理Bean
-
注解完成属性注入
-
使用过程中, 可以不用扫描,扫描是为了类上的注解
注解生效,就需要开启注解的支持
<context:annotation-config/>
9.使用Java类的方式配置Spring
JavaConfig 原来是 Spring 的一个子项目,它通过 Java 类的方式提供 Bean 的定义信息,
在 Spring4 的版本, JavaConfig 已正式成为 Spring4 的核心功能 。
1、编写一个实体类
//这里这个注解的意思,就是说明这个类被Spring接管了,注册到了容器中
@Component
public class User {
private String name;
@Value("libai")//属性注入值
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +zx
"name='" + name + '\'' +
'}';
}
}
2、新建一个config配置包,编写一个配置类
//这个也会被Spring容器托管,注册容器中,因为他本来就是一个@Component
// @Configuration代表这就是一个配置类,就和我们之前看的beans.xml
@Configuration
@ComponentScan("com.kuang.pojo")
@Import(KuangConfig2.class) //导入其他配置类
public class KuangConfig {
//注册一个Bean, 就相当于我们之前写的一个bean标签
//这个方法的名字,就相当于bean标签中的id属性
//这个方法的返回值,就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User();//就是返回要注入到bean的对象
}
}
3、测试类
public class MyTest {
public static void main(String[] args) {
//如果完全使用了配置类方式去做,我们就只能通过AnnotationConfig上下文来获取容器,通过配置类的class对象加载。
ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
User getUser = (User) context.getBean("getUser");
System.out.println(getUser.getName());
}
}
Java类导入其他配置
1、再编写一个配置类!
@Configuration
public class KuangConfig2 {
}
2、在之前的配置类中我们来选择导入这个配置类
@Configuration
@Import(MyConfig2.class) //导入合并其他配置类,类似于配置文件中的 inculde 标签
public class MyConfig {
@Bean
public Dog dog(){
return new Dog();
}
}
10.代理模式
为什么要学习代理模式? 因为这就是SpringAOP的底层(SpringAOP和SpringMVC)
代理模式的分类:
- 静态模式
- 动态模式
10.1静态模式
角色分析:
- 抽象角色:一般会使用接口或者抽象类来解决
- 真是角色: 被代理的角色
- 代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理对象的人
代码步骤:
1.接口
//租房
public interface Rent {
public void rent();
}
2.真实角色
//房东
public class Host implements Rent{
@Override
public void rent() {
System.out.println("房东要出租房子");
}
}
3.代理角色
public class Proxy implements Rent{
private Host host;
public Proxy(){
}
public Proxy(Host host) {
this.host = host;
}
@Override
public void rent() {
seeHome();
host.rent();
hetong();
fare();
}
//看房
public void seeHome(){
System.out.println("中介带你看房");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
//签合同
public void hetong(){
System.out.println("签租赁合同");
}
}
4.客户端访问代理角色
public class Client {
public static void main(String[] args) {
//房东要出租房子
Host host = new Host();
//host.rent();//直接找房东租
//代理,中介帮房东出租房子,但是,代理一般会有附属操作
Proxy proxy = new Proxy(host);
//你不用面对房东,直接找中介租房即可。
proxy.rent();
}
}
代理模式的好处:
- 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
- 公共也就交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
确点: - 一个真实角色就会产生一个代理角色;代码量会翻倍,开发效率会降低
10.2加深理解
原来是纵向开发,现在是横向开发,,例如在原有代码的基础上 增加日志,增加功能,横向的加进去,而对原来已有的功能代码不造成破坏。 例如增加代理类,在与原有实现类相同功能下,在代理类中再加入需求功能,就没有破坏原有的代码,而是操作代理类。
业务类接口
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
业务类接口实现
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("修改了一个用户");
}
public void query() {
System.out.println("查询了一个用户");
}
//1.改动原有的业务代码,在公司的大忌
}
业务类接口代理(不操作原有的Impl,,,操作代理类,防止对原有代码破坏)
public class UserServieceProxy implements UserService{
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
public void add() {
log("add");
// userService.add();
}
public void delete() {
log("delete");
userService.delete();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
//日志方法
public void log(String msg){
System.out.println("使用了"+msg+"方法");
}
}
测试实现
public class Client {
public static void main(String[] args) {
UserServiceImpl userService = new UserServiceImpl();
UserServieceProxy proxy = new UserServieceProxy();
//不是直接通过原有的对象去调用,而是通过代理类的方法去实现 调用
proxy.setUserService(userService);
proxy.add();
}
}
10.3动态代理
动态代理(即实现了增加功能,又不多增加类,上面的静态代理就多增加了类)
-
动态代理和静态代理角色一样
-
动态代理的而代理类是动态生成的,不是我们直接写好的
-
动态代理分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口-----------------JDK动态代理
- 基于类--------------------cglib
- Java字节码实现: javasist
需要了解两个类Proxy:代理,InvocationHandler:调用处理程序
动态代理的好处
- 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
- 公共也就交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
- 一个动态代理类是一个接口,一般就是对应的一类业务
- 一个动态代理类可以代理多个类,只要是实现了同一个接口即可
例一:
接口类
//租房
public interface Rent {
public void rent();
}
真实角色类
//房东
public class Host implements Rent {
@Override
public void rent() {
System.out.println("房东要出租房子");
}
}
自动生成代理类的类
//等会我们会用这个类,自动生成代理类
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);
}
@Override//处理代理类实例并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态代理的本质,就是使用反射机制实现
seeHouse();
Object result = method.invoke(rent, args);
fare();
return result;
}
public void seeHouse(){
System.out.println("中介带看房子");
}
public void fare(){
System.out.println("收中介费");
}
}
测试方法
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就是动态生成的,我们并没有写
proxy.rent();
}
}
例二:
业务接口类
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
业务接口实现类
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("修改了一个用户");
}
public void query() {
System.out.println("查询了一个用户");
}
//1.改动原有的业务代码,在公司的大忌
}
生成代理的类
//等会我们会用这个类,自动生成代理类
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);
}
@Override//处理代理类实例并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//log为增加的方法
log(method.getName());
Object result = method.invoke(target, args);
return result;
}
//例如要再实现接口实现类的基础上增加日志输出的方法
public void log(String msg){
System.out.println("执行了"+msg+"方法");
}
}
测试方法
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.delete();
}
}
11. AOP
11.1 什么是AOP
11.2 AOP在Spring中的作用
在SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice
即Aop在不改变原有代码的情况下,去增加新的功能
11.3使用Spring实现Aop
使用AOP织入,需要导入依赖包
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
AOP的实现方式一 :使用原生Spring API接口(主要是SpringAPI接口实现)
业务接口
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
业务接口实现类
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("更新了一个用户");
}
public void select() {
System.out.println("查询了一个用户");
}
}
要增加的日志类
public class Log implements MethodBeforeAdvice {
//method:要执行的目标对象的方法
//args:参数
//target: 目标对象
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
要增加的后置日志类
public class AfterLog implements AfterReturningAdvice {
@Override
//returnValue返回值
public void afterReturning(Object returnValue, Method method, Object[] object, Object o1) throws Throwable {
System.out.println("执行了"+method.getName()+"返回结果为"+returnValue);
}
}
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop" <!-- 配置aop:需要导入aop的配置-->
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
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="com.kaung.service.UserServiceImpl"></bean>
<bean id="log" class="com.kaung.log.Log"></bean>
<bean id="afterLog" class="com.kaung.log.AfterLog"></bean>
<!-- 方式一:使用原生Spring API接口-->
<!-- 配置aop:需要导入aop的配置-->
<aop:config>
<!-- 切入点:expression 表达式,execution(要执行的位置)-->
<aop:pointcut id="pointcut" expression="execution(* com.kaung.service..UserServiceImpl.*(..))"/>
<!-- 执行环绕增强-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"></aop:advisor>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>
</aop:config>
</beans>
测试方法
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理的是接口:注意点
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
AOP的实现方式一 :使用自定义来实现AOP(主要是切面定义)
自定义的类
public class DiyPointCut {
public void before(){
System.out.println("=====方法执行前=====");
}
public void after(){
System.out.println("=====方法执行后=====");
}
}
<!--方式二:自定义类-->
<bean id="userService" class="com.kaung.service.UserServiceImpl"></bean>
<bean id="diy" class="com.kaung.diy.DiyPointCut"></bean>
<aop:config>
<!--自定义切面,ref要应用的类-->
<aop:aspect ref="diy">
<!--切入点............................execution方法的* * * * * 有自己的意义-->
<aop:pointcut id="point" expression="execution(* com.kaung.service.UserServiceImpl.*(..))"/>
<!--通知-->
<aop:before method="before" pointcut-ref="point"></aop:before>
<aop:after method="before" pointcut-ref="point"></aop:after>
</aop:aspect>
</aop:config>
方式三:使用注解实现
自定义的注解类
//方式三:使用注解实现AOP
@Aspect//标注这个类是一个切面
public class AnnotationPointCut {
@Before("execution(* com.kaung.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("=====方法执行前====");
}
@After("execution(* com.kaung.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("=====方法执行后====");
}
//在环绕增强中,我们可以给定一个参数,代表我们要获取处理切入的点
@Around("execution(* com.kaung.service.UserServiceImpl.*(..))")
public void arround(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
Signature signature = jp.getSignature();//获得签名
System.out.println("signature:"+signature.getName());
//执行方法; 执行环绕之间的方法内容
Object proceed = jp.proceed();
//环绕后
System.out.println("环绕后");
}
}
配置文件
<!--方式三-->
<bean id="userService" class="com.kaung.service.UserServiceImpl"></bean>
<bean id="annototionPointCut" class="com.kaung.diy.AnnotationPointCut"></bean>
<!--开启注解支持JDK默认(proxy-target-class=“false”) cglib则为(proxy-target-class=“true”)-->
<!-- <aop:aspectj-autoproxy proxy-target-class="false"></aop:aspectj-autoproxy>-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
执行结果
环绕前
signature:add
=====方法执行前====
增加了一个用户
环绕后
=====方法执行后====
12 整合Mybatis
步骤,
1.导入相关的jar包
- junit
- mybatis
- mysql数据库
- spring相关
- aop织入
- mybatis-spring
2.编写配置文件
3.测试
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.3</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.1.RELEASE</version>
</dependency>
<!-- spring操作数据数据库还需要一个spring-jdbc-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.1.RELEASE</version>
</dependency>
<!-- 织入的包-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
<!-- mybatis 和spring整合的包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.3</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
</dependency>
</dependencies>
12.1 回忆mybatis
1.编写实体类
@Data
public class User {
private int id;
private String name;
private String pwd;
}
//@Data注解的作用
//所有属性的get和set方法
// to String 方法
// hashCode方法
// equals方法
2.编写核心配置文件
**********mybatis-config.xml
<!DOCTYPE configuration PUBLIC
"-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
<!--别名-->
<typeAliases>
<package name="com.kuang.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/springmybatis?characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<!-- 注意在此处注册-->
<mappers>
<mapper class="com.kuang.mapper.UserMapper"></mapper>
</mappers>
</configuration>
3.编写接口
public interface UserMapper {
public List<User> selectUser();
}
- 编写Mapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC
"-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.UserMapper">
<select id="selectUser" resultType="user">
select * from user;
</select>
</mapper>
- 测试
public class MyTest {
@Test
public void test() throws Exception{
String resources = "mybatis-config.xml";
//读取配置文件(注意导包)
InputStream in = Resources.getResourceAsStream(resources);
SqlSessionFactory sessionFacory = new SqlSessionFactoryBuilder().build(in);
//增删改 的自动提交事务
SqlSession sqlSession = sessionFacory.openSession(true);
UserMapper mapper = (UserMapper) sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user.toString());
}
}
}
测试结果
User(id=1, name=libai, pwd=123)
User(id=2, name=liqinzhao, pwd=152)
12.2 Mybatis-spring
简介:MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中,创建映射器 mapper 和 SqlSession 并注入到 bean 中,以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。 最终,可以做到应用代码不依赖于 MyBatis,Spring 或 MyBatis-Spring
实体类
@Data
public class User {
private int id;
private String name;
private String pwd;
}
//@Data注解的作用
//所有属性的get和set方法
// to String 方法
// hashCode方法
// equals方法
接口
public interface UserMapper {
public List<User> selectUser();
}
接口配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC
"-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kuang.mapper.UserMapper">
<select id="selectUser" resultType="user">
select * from user;
</select>
</mapper>
一开始的mybatis部分的配置文件经过整合后,几乎没了,留个别名,给mybatis存在感
*********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核心配置文件-->
<configuration>
<!--别名-->
<typeAliases>
<package name="com.kuang.pojo"/>
</typeAliases>
<!--整合剥离到spring中-->
<!-- <environments default="development">-->
<!-- <environment id="development">-->
<!-- <transactionManager type="JDBC"></transactionManager>-->
<!-- <dataSource type="POOLED">-->
<!-- <property name="driver" value="com.mysql.jdbc.Driver"/>-->
<!-- <property name="url" value="jdbc:mysql://localhost:3306/springmybatis?characterEncoding=utf-8"/>-->
<!-- <property name="username" value="root"/>-->
<!-- <property name="password" value="root"/>-->
<!-- </dataSource>-->
<!-- </environment>-->
<!-- </environments>-->
<!-- 注意在此处注册-->
<!-- <mappers>-->
<!-- <mapper class="com.kuang.mapper.UserMapper"></mapper>-->
<!-- </mappers>-->
</configuration>
实现SqlSessionTemplate,以便后面为此注入属性 也就是原来的setSqlSession,在xml中通过
来注入这个属性
== 第一种 ==
public class UserMapperImpl implements UserMapper{
//我们所有操作,都使用sqlSession来执行,在原来都是用SqlSessionTemplate
private SqlSessionTemplate sqlSession;
public void setSqlSession(SqlSessionTemplate sqlSession) {
this.sqlSession = sqlSession;
}
public List<User> selectUser() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.selectUser();
}
}
mybatis整合到spring之后的配置文件
******mybatis-dao.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">
<!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p dbcp druid
我们这里使用Spring提供的JDBC :naem的参数是已经写好的不能乱写-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/springmybatis?characterEncoding=utf-8"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!--sqlSessionFaction-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 注意此处是ref,不是value-->
<property name="dataSource" ref="dataSource"></property>
<!--很多配置文件都可以把路径拉到这个位置<property name=""></property>-->
<!--绑定mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath:com/kuang/mapper/UserMapper.xml"></property>
<!-- <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"></property>-->
</bean>
<!--SqeSessionTemplate:这就是我们使用的sqlSession,,,如果使用了继承SqlSessionDaoSupport则可
以省去这个sqlSession配置,,,实现类变成下边的UserMapperImpl2-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能用构造器注入,这个类没有set方法,有构造方法,所以选择构造中的一种注入-->
<constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
</bean>
<!--此部分放到总的applicationCOntext.xml中去也可以-->
<bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"></property>
</bean>
</beans>
第二种
实现类 UserMapperImpl2
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> selectUser() {
// SqlSession sqlSession = getSqlSession();
// UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// return mapper.selectUser();
return getSqlSession().getMapper(UserMapper.class).selectUser();
}
}
整合后的测试类
public class MyTest {
@Test
public void test() throws Exception {
/* 整合之前的测试内容
String resources = "mybatis-config.xml";
//读取配置文件(注意导包)
InputStream in = Resources.getResourceAsStream(resources);
SqlSessionFactory sessionFacory = new SqlSessionFactoryBuilder().build(in);
//增删改 的自动提交事务
SqlSession sqlSession = sessionFacory.openSession(true);
UserMapper mapper = (UserMapper) sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user.toString());
}
*/
//mybatis整合到spring之后,此处就没有关于mybatis内容了:
ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
UserMapper userMapper = (UserMapper) context.getBean("userMapper");
List<User> users = userMapper.selectUser();
for (User user : users) {
System.out.println(user);
}
}
}
1.编写数据源配置
2.sqlSessionFactory
3.sqlSessionTemplate
4.需要给接口加实现类
5.将自己写的实现类,注入到Spring中
6.测试使用即可
核心内容
<!--sqlSessionFaction-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"></property>
</bean>
<!--SqeSessionTemplate:这就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory"></constructor-arg>
</bean>
13 .声明式事务
1.事务回顾
- 把一组业务当成一个业务来做;要么都成功,要么都失败,
- 事务在项目开发中,十分重要,涉及到数据的一致性问题,不能马虎
- 确保完整性和一致性
事务的ACID原则
- 原子性
- 一致性
- 隔离性:多个业务可能操作同一个资源,防止数据损坏
- 持久性:事务一旦提交,无论发生什么问题,结果都不会被影响,被持久化的写道存储器中。
2.Spring中的事务管理
- 声明式事务:AOP
- 编程式事务:需要代码中,进行事务的管理
思考:
为什么需要事务:(例如存钱取钱)
- 如果不配置事务,可能存在数据提交不一致的情况;
- 如果我们不在Spring中配置声明式事务,我们就需要在代码中手动配置
- 事务在项目的开发中十分重要,涉及到数据的一致性和完整性问题,不容马虎
接口类
public interface UserMapper {
public List<User> selectUser();
//以下两个测试事务
public int addUser(User user);
public int deleteUser(int id);
}
接口类配置文件
<?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.kuang.mapper.UserMapper">
<select id="selectUser" resultType="user">
select * from user;
</select>
<insert id="addUser" parameterType="user">
insert into user(id,name,pwd) values(#{id},#{name},#{pwd});
</insert>
<delete id="deleteUser" parameterType="int">
delete from user where id=#{id};
</delete>
</mapper>
接口类实现类
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
@Override
public List<User> selectUser() {
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
//将addUser()和deleteUser()也添加到此处 来测试事务
User user = new User(5,"laowang","1213");
mapper.addUser(user);
mapper.deleteUser(5);
return mapper.selectUser();
}
@Override
public int addUser(User user) {
return getSqlSession().getMapper(UserMapper.class).addUser(user);
}
@Override
public int deleteUser(int id) {
return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
}
}
配置文件mybatis
<?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核心配置文件-->
<configuration>
<typeAliases>
<package name="com.kuang.pojo"/>
</typeAliases>
</configuration>
配置文件spring-dao
<?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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/bean 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-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/springmybatis?characterEncoding=utf-8"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!--sqlSessionFaction-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="configLocation" value="classpath:mybatis-config.xml"></property>
<property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"></property>
</bean>
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--<constructor-arg ref="dataSource"></constructor-arg> -->
<!--或者-->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 事务的实现 -->
<!--结合AOP实现事务的织入-->
<!--配置事务通知:-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--给那些方法配置事务-->
<!--配置事务的传播特性-->
<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:method>
</tx:attributes>
</tx:advice>
<!--配置事务切入-->
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.kuang.mapper*.*(..)))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"></aop:advisor>
</aop:config>
</beans>
测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
List<User> users = context.getBean("userMapper",UserMapper.class).selectUser();
for (User user : users) {
System.out.println(user);
}
}
}