1.Spring
1.1 简介
-
Spring : 春天 —>给软件行业带来了春天
-
2002年,Rod Jahnson首次推出了Spring框架雏形interface21框架。
-
Spring框架以interface21框架为基础,经过重新设计,发布了1.0正式版。
-
Rod Johnson,Spring Framework创始人 , 他是悉尼大学的博士,然而他的专业不是计算机,而是音乐学。
-
Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
-
SSH:struct2+Spring+Hibernate
-
SSM:SpringMVC+Spring+Mybatis
官网 : http://spring.io/
官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/
GitHub : https://github.com/spring-projects
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.13</version>
</dependency>
1.2 优点
- Spring是一个开源免费的框架 , 容器 .
- Spring是一个轻量级的框架 , 非侵入式的 .
- 控制反转 IoC , 面向切面编程 Aop
- 对事物事务的支持 , 对框架整合的支持
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器(框架)。
1.3 组成
1.4 扩展
在Spring的官网有这个介绍,现代化的java开发,说白了就是基于spring的开发
-
Spring Boot
- 一套快速配置脚手架
- 基于Spring Boot 快速开发单个微服务;
-
Spring Cloud
- 是基于Spring Boot实现的;
2.IOC理论推导
在我们之前的业务中,用户的需求可能会影响我们原来的代码,我们需要根据用户的需求去修改源代码!如果程序代码量十分强大,修改一次的成本代价十分昂贵
我们使用一个set接口实现,已经发生了革命的改变
private UserDao userDao;
// 利用set实现
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
- 之前,程序是主动创建对象,控制权在程序员手上
- 使用set注入后,程序不再有主动性,而是变成了被动的接收对象
这种思想,从本质上解决了问题,我们程序员不用再去管理对象的创建了,系统的耦合性大大降低,可以更加专一的在业务的实现上,这是IOC的原型
IOC本质:
控制反转IoC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现IoC的一种方法,也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。
控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)。
3.HelloSpring
- Hello 对象是谁创建的 ? hello 对象是由Spring创建的
- Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的
这个过程就叫控制反转 :
- 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
- 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的.
IOC是一种编程思想,由主动的编程变成被动的接收
可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .
ok,到了现在,我们彻底不用再程序中去做改动了,要实现不同的操作,只需要在xml配置文件中进行修改,所谓的IOc,一句话搞定:对象由spring来创建,管理,装配!
4.IOC创建对象的方式
-
使用无参构造创建对象,默认
-
假设我们要使用有参构造创建对象
1.下标赋值
<!-- 下标赋值-->
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg index="0" value="狂神"/>
</bean>
2.类型
<!-- 通过类型创建,不建议使用-->
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg type="java.lang.String" value="狂 神"/>
</bean>
- 参数
<!-- 通过参数直接,不建议使用-->
<bean id="user" class="com.kuang.pojo.User">
<constructor-arg name="name" value="1"/>
</bean>
总结:在配置文件加载的时候,容器中管理的对象就已经初始化了
5.Spring配置
5.1 别名
<!-- 别名:如果添加了别名,我们也可以使用别名来获取这个对象-->
<alias name="user" alias="userNew"/>
5.2 配置
<!--
id:bean的唯一标识符,也就是相当于我们学的对象名
class:bean对象所对应的全限定名:包名+类型
name:也就是别名,而且name可以同时取多个别名
-->
<bean id="userT" class="com.kuang.pojo.UserT" name="usre2 u2,u3">
<property name="name" value="西部开源"/>
</bean>
5.3 import
这个import,一般用于团队开发使用,它可以将多个配置文件导入合并为一个
假设,现在项目中有多人开发,这三个人赋值不同的类开发,不同的类需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的
- 张三
- 里斯
- 王五
- applicationContext.xml
<import resource="beans.xml"/>
<import resource="beans1.xml"/>
<import resource="beans2.xml"/>
使用的时候,直接使用总的配置就可以了·
6.依赖注入
6.1 构造器注入
前面已经讲过
6.2 Set方式注入 重点
- 依赖注入:Set注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中的所有属性,由容器来注入
环境搭建:
- 复杂类型
package com.kuang.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
- 真实测试对象
package com.kuang.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 +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + 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.kuang.pojo.Student">
<!-- 第一种普通值注入value-->
<property name="name" value="秦疆"/>
</bean>
</beans>
- 测试类
import com.kuang.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.applet.AppletContext;
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.kuang.pojo.Address"/>
<bean id="student" class="com.kuang.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>
</list>
</property>
<!-- Map-->
<property name="card">
<map>
<entry key="身份证" value="12311111111"/>
<entry key="银行卡" value="12311111111"/>
</map>
</property>
<!-- Set-->
<property name="games">
<set>
<value>LOL</value>
<value>COC</value>
<value>COC</value>
</set>
</property>
<!-- null-->
<property name="wife">
<null/>
</property>
<!-- properties-->
<property name="info">
<props>
<prop key="driver">12312</prop>
<prop key="url">男</prop>
<prop key="username">root</prop>
<prop key="password">root</prop>
</props>
</property>
</bean>
</beans>
6.3 扩展方式注入
我们可以使用p命名空间和c命名空间进行注入
<?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/c"
xmlns:p="http://www.springframework.org/schema/p"
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="qinj" p:age="18"/>
<!-- c命名注入 可以直接注入属性的值:property-->
<bean id="user2" class="com.kuang.pojo.User" c:name="qinj" c:age="18"
</beans>
测试:
import com.kuang.pojo.Student;
import com.kuang.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.applet.AppletContext;
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());
}
@Test
public void test(){
ApplicationContext context=new ClassPathXmlApplicationContext("userbeans.xml");
User user=context.getBean("user",User.class);
System.out.println(user);
}
}
注意点:p命名空间和c命名空间不能直接使用,需要导入xml约束
6.4 bean的作用域
- 代理模式(Spring默认机制)
- 原型模式:每次从容器中get的时候,都会产生一个新的对象
- 其余的request,session,application只能在web开发中使用到
7.Bean的自动装配
- 自动装配是spring满足bean依赖一种方式
- spring会在上下文中自动寻找,并自动给bean装配属性
在Spring中有三种装配的方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean 重要
7.1 测试
环境搭建:一个人有两个宠物
7.2 ByName自动装配
<!--
byname会自动在容器中上下文中查找,和自己对象set方法后面的值对应放入beanid
-->
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
<property name="name" value="小狂神"/>
</bean>
7.3 ByType自动装配
<!--
byname会自动在容器中上下文中查找,和自己对象set方法后面的值对应放入beanid
byname会自动在容器中上下文中查找,和自己对象属性类型的bean
-->
<bean id="people" class="com.kuang.pojo.People" autowire="byType">
<property name="name" value="小狂神"/>
</bean>
小结:
- byname的时候,需要保证所有bean的id唯一,并且这个bean需要和自动注入的属性的set方法的值一致
- byname的时候,需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致
7.4 使用注解实现自动装配
jdk1.5支持的注解,spring2.5就支持注解了
要使用注解须知:
- 导入约束
- 配置注解的支持
<?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">
<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对象注入
@Resource注解
小结:
@Autowired和@Resource的区别:
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired通过byType的方式实现,而且必须要求这个对象存在(常用)
- @Resource默认通过byname的方式实现,如果找不到名字,则通过byType实现实现!如果两个都找不到的情况下,就报错
- 执行顺序不同:@Autowired通过byType的方式实现
8.使用注解开发
在Spring4之后,要使用注解开发,必须保证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
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config/>
</beans>
-
bean
-
属性如何注入
package com.kuang.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于 <bean id="user" class="com.kuang.pojo.User"/>
//@Component组件
@Component
public class User {
//相当于<property name="name" value="ks"/>
@Value("ks")
public String name;
}
- 衍生的注解
@Component有几个衍生注解,我们在web开发中,会按照MVC三层架构分层
-
dao @Repository
-
service @Service
-
controller @Controller
这四个注解功能都是一样的,都是代表将某个类注册到spring中,装配bean
- 自动装配置
@Autowired:自动装配通过类型,名字
如果@Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value="XXX")
@Nullable 字段标记了这个注解,说明这个字段可以为null
@Resource :自动装配通过名字,类型
- 作用域
@Component
@Scope("singleton")
public class User {
//相当于<property name="name" value="ks"/>
@Value("ks")
public String name;
}
- 小结
xml和注解
- xml更加万能,适用于任何场合,维护简单方便
- 注解不是自己类使用不了,维护相对复杂
xml与注解最佳实践:
- xml用来管理bean
- 注解只负责完成属性的注入
我们在使用过程中,只需要注意一个问题,必须让注解生效,就需要开启注解的支持
<context:component-scan base-package="com.kuang.pojo"/>
<context:annotation-config/>
9.使用java的方式配置Spring
我们现在要完全不使用spring的xml配置了,全权交给java来做
实体类
package com.kuang.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("qs")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
//配置文件
package com.kuang.comfig;
import com.kuang.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.kuang.pojo")
@Import(kuangConfig.class)
public class kuangConfig {
//注册一个bean。就相当于我们之前写的一个bean标签
// 这个方法的名字,就相当于bean标签中的id属性
// 这个方法的返回值,就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User();//就是返回要注入到bean的对象
}
}
//测试
import com.kuang.pojo.User;
import com.kuang.comfig.kuangConfig;
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(kuangConfig.class);
User getUser=(User) context.getBean("getUser");
System.out.println(getUser.getName());
}
}
10.代理模式
为什么要学习代理模式?因为这就是SpringAOP的底层(SpringAOP和SpringMVC)
代理模式分类:
- 静态代理
- 动态代理
10.1 静态代理
角色分析:
- 抽象角色:一般会使用接口或者抽象类来解决
- 真实角色:被代理的角色
- 代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
- 客户:访问代理对象的人
代码步骤
1.接口
package com.kuang.demo01;
public interface Rent {
public void rent();
}
2.真实角色
package com.kuang.demo01;
//房东
public class Host implements Rent{
public void rent(){
System.out.println("出租");
}
}
3.代理角色
package com.kuang.demo01;
public class Proxy implements Rent{
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
public void rent() {
host.rent();
}
//看房
public void seeHouse(){
System.out.println("看房");
}
public void hetogn(){
System.out.println("签合同");
}
public void fare(){
System.out.println("中介费");
}
}
4.客户端访问代理角色
package com.kuang.demo01;
public class Client {
public static void main(String[] args) {
Host host=new Host();
//代理,中介帮房东租房子,但是代理一般会有一些附属操作
Proxy proxy=new Proxy(host);
//你不用面对房东,直接找中介租房即可
proxy.rent();
}
}
代理模式的好处:
- 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
- 公共1也就是交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
缺点:
- 一个真实角色就会产生一个代理角色,代码量就会翻倍,开发效率会变低
10.2 加深理解
package com.kuang.demo02;
public interface Userservice {
public void add();
public void delete();
public void update();
public void query();
}
package com.kuang.demo02;
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("查询");
}
}
package com.kuang.demo02;
public class UserServiceProxy 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+"方法");
}
}
package com.kuang.demo02;
public class Client {
public static void main(String[] args) {
UserServiceImpl userService=new UserServiceImpl();
UserServiceProxy proxy=new UserServiceProxy();
proxy.setUserService(userService);
proxy.query();
}
}
10.3 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的,不是我们直接写好的
- 动态地阿里分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口 JDK动态代理
- 基于类:cglib
- java字节码实现:javasist
需要了解两个类:Proxy:代理 InvocationHandler:调用处理程序
动态代理的好处:
- 可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
- 公共1也就是交给代理角色,实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
- 一个动态代理类代理的是一个接口,一般就是对应的一类业务
- 一个动态代理类可以代理多个类,只要实现了同一个接口就好了
11.AOP
11.1 什么是AOP
AOP(Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
11.2 AOP在Spring中的作用
提供声明式事务;允许用户自定义切面
以下名词需要了解下:
- 横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
- 切面(ASPECT):横切关注点 被模块化 的特殊对象。即,它是一个类。
- 通知(Advice):切面必须要完成的工作。即,它是类中的一个方法。
- 目标(Target):被通知对象。
- 代理(Proxy):向目标对象应用通知之后创建的对象。
- 切入点(PointCut):切面通知 执行的 “地点”的定义。
- 连接点(JointPoint):与切入点匹配的执行点。
SpringAOP中,通过Advice定义横切逻辑,Spring中支持5种类型的Advice:
即 Aop 在 不改变原有代码的情况下 , 去增加新的功能 .
11.3 使用Spring实现AOP
【重点】使用AOP织入,需要导入一个依赖包!
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
方式一:使用Spring的API接口 主要是SpringAPI接口实现
方式二:自定义来实现AOP 主要是切面定义
方式三:使用注解实现
12.整合Mybatis
步骤:
- 导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop织入
- mybatis-spring(new)
- 编写配置文件
- 测试
12.1 回忆mybatis
- 编写实体类
- 编写核心配置文件
- 编写接口
- 编写mapper.xml
- 测试
12.2 Mybatis-Spring
1.编写数据源
2.sqlSessionFactory
3.SqlSessionTemplate
4.需要给接口加实现类
13.声明式事务
13.1回顾事务
- 把一组事务当成一个业务来做:要么都成功,要么都失败
- 十五在项目开发中,十分的重要,涉及到数据的一致性问题,不能马虎
- 确保完整性和一致性
事务ACID原则:
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源,防止数据损坏
- 持久性
- 事务一旦提交,无论系统发生什么问题,结果都不会被影响,被持久化的写到存储中
13.2 spring中的事务管理
事务管理:AOP
编程式事务:需要在代码中,进行事务的管理
为什么需要事务:
- 如果不配置事务,可能存在数据提交不一致的情况下
- 如果我们不在SPRING中去配置声明式事务,我们就需要在代码中手动配置事务
- 事务在项目的开发中十分重要,涉及到数据的一致性和完整性问题,不容马虎