Spring学习
1、Spring
1.1 简介
- Spring是一个开源框架，它由[Rod Johnson](https://baike.baidu.com/item/Rod Johnson)创建。它是为了解决企业应用开发的复杂性而创建的。
- Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
- Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
- Spring理念：使现有技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
官网：https://spring.io/projects/spring-framework#overview
官方下载地址： https://repo.spring.io/release/org/springframework/spring
Github: https://github.com/spring-projects/spring-framework
Maven依赖：
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.9.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.9.RELEASE</version>
</dependency>
1.2 优点
- Spring是一个开源的免费框架（容器）！
- Spring是一个轻量级、非入侵式的框架！
- 控制反转（IOC）、面向切面编程（AOP）
- 支持事务的处理，对框架整合的支持！
总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！
1.3 组成
1.4 拓展
现代化的Java开发！是基于Spring的开发
- Spring Boot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速开发单个微服务
- 约定大于配置
- Spring Cloud
- 基于SpringBoot实现
2、IOC理论推导
在我们之前的业务中，用户的需求会影响我们原来的代码。我们需要根据用户的需求去修改源代码！如果程序代码量十分大，修改一次的成本十分昂贵
使用一个Set接口实现
private UserDao userDao;
// 利用set进行动态实现值的注入！
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
- 之前程序是主动创建对象，控制权在程序员手上！
- 使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象！
这种思想，从本质上解决了问题，程序员不用再去管理对象的创建，系统的耦合性大大降低，可以更加专注业务的实现！这是IOC的原型
- 控制反转：对象A获得依赖对象B的过程,由主动行为变为了被动行为，控制权颠倒过来了。
- 依赖注入：所谓依赖注入，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。
3、IOC创建对象的方式
-
使用无参构造创建对象，默认！
-
假设使用有参构造创建对象
-
下标赋值
<!--有参创造 1.下标赋值 --> <bean id="user" class="com.guo.pojo.User"> <constructor-arg index="0" value="郭玉红"/> </bean> -
通过类型创建
<!-- 2. 类型匹配 （不建议使用！） --> <bean id="user" class="com.guo.pojo.User"> <constructor-arg type="java.lang.String" value="郭玉红"/> </bean> -
通过参数名来设置
<!-- 第三种， 直接通过参数名来设置--> <bean id="user" class="com.guo.pojo.User"> <constructor-arg name="name" value="哈哈"/> </bean>总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！
-
5、Spring配置
5.1 别名
<!--别名，如果添加了别名，我们可以使用别名来获取到这个对象 -->
<alias name="user" alias="user2"/>
5.2 Bean的配置
<!--
id: bean的唯一标识符，也就是相当于我们学的对象名
class: bean对象所对应的全限定名：包名+类型
name:也是别名，而且name可以取多个别名
-->
<bean id="user" class="com.guo.pojo.User" name="user3,user4,user5">
<property name="name" value="郭玉红"/>
</bean>
5.3 import
一般用于团队开发使用，可以将多个配置文件，合并为一个
假设项目有多人开发，三人负责不同的类开发，不同的类需注册不同的Bean中，我们可以用import将所有的beans.xml合并为一个，使用的时候，直接使用总的。
6、依赖注入
6.1 构造器注入
6.2 Set方式注入【重点】
-
依赖注入：Set注入！
- 依赖：bean对象的创建依赖于容器！
- 注入：bean对象中的所有属性，由容器注入！
-
复杂类型
public class Address { private String addrerss; public String getAddrerss() { return addrerss; } public void setAddrerss(String addrerss) { this.addrerss = addrerss; } } -
真实测试对象
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; } -
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.guo.pojo.Student"> <!-- 第一种，普通值注入，value --> <property name="name" value="郭玉红"/> </bean> </beans> -
测试类
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.getAddress()); } } -
完善注入信息
<?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="address" class="com.guo.pojo.Address"> <property name="addrerss" value="西安"/> </bean> <bean id="student" class="com.guo.pojo.Student"> <!-- 第一种，普通值注入，value --> <property name="name" value="郭玉红"/> <!-- 第二种，Bean注入，ref--> <property name="address" ref="address"/> <!-- 第三种，数组注入 --> <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="4115556655522"/> <entry key="银行卡" value="46434464644611"/> </map> </property> <!-- Set --> <property name="games"> <set> <value>LOL</value> <value>COC</value> <value>BOB</value> </set> </property> <property name="wife"> <null></null> </property> <!--Properties --> <property name="info"> <props> <prop key="学号">2020262798</prop> <prop key="性别">男</prop> <prop key="姓名">小明</prop> </props> </property> </bean> </beans>
6.3 Bean的作用域
1. 单例模式
<bean id="user2" class="com.guo.pojo.User" scope="singleton"/>
- 原型模式: 每次从容器中get的时候，都会产生一个新对象！
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>
- 其余的request、session、application 这些只能在web开发中使用到！
7、Bean的自动装配
- 在xml中显式的装配
- 在java中显式装配
- 隐式的自动装配bean【重要】
7.1 ByName自动装配
<!--
byName: 会自动在容器上下文中查找和自己对象set方法后面的值对应的beanid;
-->
<bean id="people" class="com.guo.pojo.People" autowire="byName">
<property name="name" value="或玉红"/>
</bean>
7.2 ByType自动装配
<!--
byType: 会自动在容器上下文中查找和自己对象属性类型相同的bean
-->
<bean id="people" class="com.guo.pojo.People" autowire="byType">
<property name="name" value="或玉红"/>
</bean>
小结：
- byname的时候，需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法值一致！
- byname的时候，需要保证所有的bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！
7.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" 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 默认byName方式
-
直接在属性上使用即可！也可以在set方式上使用！
-
使用Autowired我们可以不用编写Set方法，前提是这个自动装配的属性在IOC（Spring)容器中存在，且符合名字byname
-
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解完成的时候，可以使用@Qualifier(value="xxx") 去配置@Autowired的使用，指定一个唯一的bean对象注入！
@Autowired @Qualifier(value = "ccat111") private Cat cat; @Autowired @Qualifier(value = "fsfsf") private Dog dog; private String name;小结：
@Resource和@Autowired的区别：
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byname的方式实现
- @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现
-
8、使用注解开发
- 要使用注解开发，必须保证aop的包导入
- 使用注解需导入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
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>
8.1 bean
@Component 组件，放在类上，说明这个类被Spring管理了，就是Bean
8.2 属性如何注入
@Component
public class User {
// 方式一
@Value("按最帅")
public String name;
// 方式二
@Value("郭玉红")
public void setName(String name) {
this.name = name;
}
}
8.3 衍生的注解
@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
- dao [@Repository]
- service[@Service]
- controller[@Controller]
8.4 自动装配注解
8.5 作用域
@Component
@Scope("prototype")
public class User {
// 方式一
@Value("按最帅")
public String name;
// 方式二
@Value("郭玉红")
public void setName(String name) {
this.name = name;
}
}
8.6 小结
xml与注解：
- xml更加万能，适合于任何场所！维护简单方便
- 注解不是自己的类使用不了，维护相对复杂！
xml与注解最佳实践：
- xml用来管理bean
- 注解只负责完成属性的注入
- 我们在使用的过程中，只需注意一个问题必须让注解生效，就需要开启注解的支持
<!--指定要扫描的包，这个包下的注解就会生效 -->
<context:component-scan base-package="com.guo.pojo"/>
<context:annotation-config/>
9、使用Java的方式配置Spring
完全不使用Spring的xml配置了，全权交给java来做
实体类
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("郭玉红")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置文件
package com.guo.config;
import com.guo.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
/**
* @Date: 2020/11/4
* @author: 王瑞哲
* @version：1.0
*/
@Configuration // 这个也会被Spring容器托管注册到容器中，因为他本来就是一个@Component 代表这是一个配置类，和之前的xml文件一致
@ComponentScan("com.guo.pojo")
public class guoConfig {
// 注册一个bean,就相当于之前写的一个bean
// 这个方法的名字，就相当于bean标签的id属性
// 这个方法的返回值，就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User(); // 就是要返回要注入到bean的对象！
}
}
这种纯Java的配置文件，在SpringBoot中随处可见！
10、AOP(代理模式)
代理模式的分类：
- 静态代理
- 动态代理
10.1 静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理后，一般会做一些附属操作
- 客户：访问代理对象的人！
代码步骤：
- 接口
// 租房
public interface Rent {
public void rent();
}
-
真实角色
public class Host { public void rent(){ System.out.println("房东要出租房子！"); } } -
代理角色
public class proxy implements Rent{
private Host host;
public proxy() {
}
public proxy(Host host) {
this.host = host;
}
public void rent(){
seeHoude();
host.rent();
hetong();
}
public void seeHoude(){
System.out.println("中介带你看房！");
}
public void hetong(){
System.out.println("签合同！");
}
-
客户端访问代理角色
public class Client { public static void main(String[] args) { // 房东要租房了 Host host = new Host(); //代理，中介帮房东租房子，但是代理一般有些附属操作！ proxy proxy = new proxy(host); // 你不用面对房东，直接找中介即可! proxy.rent(); } }
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共业务交给代理角色！实现业务的分工！
- 公共业务发生拓展时，方便集中管理！
缺点：
- 一个真实角色就会产生一个代理角色：代码量会翻倍开发效率会降低！
10.2 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口---JDk动态代理
- 基于类：cglib
- java字节码实现：javasist
- 一个动态代理类代理的是一个接口，一般对应一类业务
- 一个动态代理可以代理多个类，只要是实现了同一个接口即可
11、AOP
11.1 什么是AOP
11.2 使用Spring实现Aop
导入依赖
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
方式一：使用Spring的API接口【主要SpringAPI接口实现】
<?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.kuang.service.UserServiceImpl"/>
<bean id="log" class="com.kuang.log.log"/>
<bean id="afterLog" class="com.kuang.log.afterLog"/>
<!-- 方式一：使用原生SpringApI接口-->
<!--配置aop:需要导入aop的约束 -->
<aop:config>
<!--切入点：expression: 表达式：execution(要执行的位置！) -->
<aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
<!--执行环绕增加！ -->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
方式二：自定义来实现AOP【主要是切面定义】
<!--方式二：自定义类 -->
<bean id="diy" class="com.kuang.diy.DiyPointCut"/>
<aop:config>
<!--自定义切面，ref要引用的类 -->
<aop:aspect ref="diy">
<!--切入点 -->
<aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
<!--通知 -->
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
</aop:aspect>
</aop:config>
方式三：使用注解来实现AOP
12、整合Mybatis
步骤：
-
导入相关jar包
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.49</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.9.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.9.RELEASE</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.5</version> </dependency> </dependencies>12.1 回忆mybatis
- 编写实体类
- 编写核心配置文件
- 编写接口
- 编写Mapper.xml
- 测试
12.2 Mybatis-spring
- 编写数据源配置
- sqlSessionFactory
- sqlSessionTemplate
- 需要给接口加实现类
- 将自己写的实现类，注入到Spring中
- 测试使用即可
<?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">
<!--DataSource:使用Spring的数据源替换Mybatis的配置
我们使用这里Spring提供的JDBC-->
<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=false&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="wrz485251mysql"/>
</bean>
<!--线程池 -->
<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/guo/mapper/UserMapper.xml"/>
</bean>
<!--SqlSessionTemplate:就是我们使用的sqlSession -->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--只能使用构造器注入 sqlSessionFactory，因为它没有set方法 -->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<bean id="userMapper" class="com.guo.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
13、声明式事务
13.1 回顾事务
- 把一组事务当成一个业务来做，要么都成功，要么都失败！
- 事务在项目开发中，十分重要，涉及数据一致性问题
- 确保完整性和一致性
事务ACID原则
-
原子性
-
一致性
-
隔离性
多个业务可能操作同一个资源，防止数据损坏
-
持久性
事务一旦提交，无论系统发生什么问题，结果都不会再影响，数据被持久化的写到存储器中！
13.2 spring中的事务管理
- 声明式事务：AOP
<!--配置声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</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:attributes>
</tx:advice>
<!--配置事务切入 -->
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.guo.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>
- 编程式事务：需要在代码中进行事务的管理
为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况
- 如果不在spring中去配置声明式事务，就需在代码中手动配置事务
- 事务在项目开发中很重要，涉及到数据一致性和完整性问题
浙公网安备 33010602011771号