Spring_Java

1、Spring 1.1、简介

spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
SSH : Struct2 + SPring + Hibernate
SSM : SpringMVC + Spring + Mybatis

Spring Framework官网

Spring官方文档

[Spring中文文档](Spring Framework 中文文档 - Spring Framework 5.1.3.RELEASE Reference | Docs4dev)

包



    org.springframework
    spring-webmvc
    5.3.15



    org.springframework
    spring-jdbc
    5.3.15

1.2、优点

Spring是一个开源的免费的框架(容器)
Spring是一个轻量级的、非入侵式的框架
控制反转(IOC)、面向切面编程(AOP)
支持事务的处理，对框架的整合支持

1.3、组成

1.4、扩展

现代化的Java开发，基于Spring的开发！

Spring Boot
- 一个快速开发的脚手架
- 基于SPringBoot可以快速的开发单个微服务
- 约定大于配置
Spring Cloud
- SpringCloud是基于SrringBoot实现的

现在大多数公司都在使用SpringBoot进行可快速开发，学习SpringBoot的前提，需要完全张婉Spring和SpringMVC！承上启下作用！

弊端：发展太久之后，违背了原有的理念，配置十分繁琐 – “配置地狱”

2、IOC理论推导

UserDao 接口
UserDaoImpl 实现类
UserSErvice 业务接口
UserServiceImpl 业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！如果程序代码量非常大，修改一次的成本代价十分昂贵

我们使用一个Set接口实现，发生了革命性的变化！

private UserDao userDao;

//利用set进行动态实现 值的注入
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

之前，程序是主动创建对象，控制权在程序员手上
使用了set注入后，程序不再具有主动性，二十百年出来被动的接受对象

这种思想，从本质上解决了问题，不再需要管理对象的创建了！！！系统耦合性大大降低，可以更加专注在业务的实现上

IOC本质

控制反转IOC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方式。

没有IoC的程序中，我们使用面向对象编程，对象的创建与与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述 (XML或注解) 并通过第三方去生产或获取特定对象的方式，在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入 (Dpendency Injection,DI)

3、HelloSpring

导入jar包



    org.springframework
    spring-webmvc
    5.3.15

编写实体类

package com.lyd.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 + ''' +
                '}';
    }
}

编写beans.xml配置文件

测试

import com.lyd.pojo.Hello;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Mytest {
    @Test
    public void test(){
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
        //我们的对象现在都在Spring中的管理了，我们要使用，直接去里面取出来就可以
        Hello hello = (Hello) context.getBean("hello");
    }
}

4、IoC创建对象

默认使用无参构造创建对象
假设我们要使用有参构造创建对象
- 下标赋值
```
    
```
- 类型
```
    
```
- 参数名
```
    
```

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了

5、Spring配置 5.1、别名

5.2、Bean的配置

5.3、import

import一般用于团队开发，可以将配置文件，导入合并为一个

假设，现在项目有多个人开发，这几个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的

applicationcontext

6、依赖注入 6.1、构造器注入

前面讲了

6.2、Set注入 (重点)

依赖注入：set注入！
- 依赖：bean对象的创建依赖于容器
- 注入：bean对象中的所有属性，由容器来注入

环境搭建

复杂类型

public class Address {
    private String address;
    
    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

真实测试对象

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List hobbies;
    private Map card;
    private Set games;
    private String wife;
    private Properties info;
}

beans.xml

测试类

import com.lyd.pojo.Student;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Mytest {
    @Test
    public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getAddress());
    }
}

完善注入信息

6.3、扩展方式注入

6.4、bean的作用域

scope=“singleton” 单例模式（默认模式）

原型模式：每次从容器中get的时候，都会产生一个新对象

其余的request 、session、application、这些只能在web开发中用到

7、bean的自动装配

自动装配是Spring满足bean依赖一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性

在Spring中有三种装配方式

在xml中显式配置
在java中显式配置
隐式的自动装配bean [重要]

7.1、测试

环境搭建 : 一个人有两个宠物

7.2、ByName自动装配

7.3、ByType自动装配

小结：

byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

7.4、使用注解实现自动装配 (重点)

jdk1.5支持的注解，Spring2.5就支持注解了

使用注解须知：

导入约束 : context约束
配置注解的支持 : context:annotation-config/ (重点)

@Autowired

直接在属性上使用即可，也可以在set方法上使用

使用Autowired我们可以不用写set方法啦

前提是这个属性在IOC容器中存在，且符合byName规范

Autowired 按类型自动装配

科普：

@Nullable 字段标记了这个属性，说明这个属性可以为null

public @interface Autowired {
    boolean required() default true;
}
如果@Autowired(required = false)说明可以为null 否则不允许为空

如果@Autowired自动装配的环境比较复杂

可以配合使用@Qualifier(value = “xxx”)去配置byName装配，指定唯一bean对象注入

@Resource Java原生注解

如有指定的name属性，先按该属性进行byName方式查找装配
其此次再进行默认的byName进行装配
最后按照byType进行自动装配
都没有就寄

8、使用注解开发

Spring4之后，要使用注解开发，必须要保证aop的包导入

使用注解需要导入context约束，增加注解的支持

bean

属性如何注入

    public String name;
    
    //相当于 
    @Value("炎东")
    public void setName(String name) {
        this.name = name;
    }

衍生的注解

@Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层
- dao [@Repository]
- service [@Service]
- controller [@Controller]
这四个注解功能一样，都是代表将某个类注册到Spring中，装配Bean

自动装配

@Autowired : 自动装配，通过类型、名字
	如果Autowired不能唯一自动装配上，需要配合@Qualifier(value="xxx")
@Nullable : 字段标记了这个注解，说明这个字段可以为null
@Resource : 自动装配，通过名字、类型

作用域

//等价于 在xml中注册了
@Component
//作用域 : 单例模式
@Scope("singleton")
public class User {

    public String name;

    //相当于 
    @Value("炎东")
    public void setName(String name) {
        this.name = name;
    }
}

小结

xml 与注解：
- xml更加万能，适用于任何场合！维护简单方便
- 注解不是自己的类使用不了，维护相对复杂
最佳实践：
- xml用来管理bean
- 注解只负责属性的注入
- 使用过程中，只需要注意：让注解生效，要提供注解的支持

9、使用Java方式配置Spring

完全不适用Spring 的xml配置，全权交给Java来做

JavaConfig是Spring的一个子项目，Spring4之后，成为了核心功能

实体类

@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 + ''' +
                '}';
    }
}

配置类

@Configuration
@ComponentScan("com.lyd.pojo")
@Import(LydConfig2.class)
public class LydConfig {

    //注册一个bean ， 就相当于我们之前写的一个bean标签
    //这个方法的名字， 就相当于bean标签中的id
    //这个方法的返回值， 就相当于bean标签中的class
    @Bean
    public User user(){
        return new User();
    }
}

这种纯java的配置方式，在SpringBoot中随处可见

10 、代理模式

这是SpringAOP的底层

[SpringAOP 和 SpringMVC]

代理模式的分类：

静态代理
动态代理

10.1、静态代理

角色分析:

抽象角色：一般会使用接口或抽象类
真实角色：被代理的角色
代理角色：代理真实角色，之后实现一些附属操作
客户：访问代理对象的人

步骤：

接口

package com.lyd.demo01;

//租房
public interface Rent {
    public void rent();
}

真实角色

package com.lyd.demo01;

//房东
public class Host implements Rent{

    public void rent(){
        System.out.println("房东要出房");
    }
}

代理角色

package com.lyd.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();
        fare();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    //收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

客户端访问代理角色

package com.lyd.demo01;

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮房东租房子，但是代理角色一帮会做点其他的事
        Proxy proxy = new Proxy(host);
        //直接找中介租房
        proxy.rent();
    }
}

代理模式的好处：

可以使真实角色的操作更加纯粹，不用灌注一些公共的业务
公共业务交给代理角色，实现了业务的分工
公共业务发生扩展的时候，钢板集中管理

缺点：

一个真实角色就会产生一个代理角色：代码量翻倍 -> 开发效率变低

AOP

10.2、动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生存的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口 — JDK动态代理 [在这里学这个]
- 基于类 — cglib
- java字节码实现： javasist

需要了解两个类： Proxy：代理， InvocationHandler：调用处理程序

好处：

可以使真实角色的操作更加纯粹，不用灌注一些公共的业务
公共业务交给代理角色，实现了业务的分工
公共业务发生扩展的时候，钢板集中管理
一个动态代理类代理的是一个接口，代理一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可

InvocationHandler

package com.lyd.demo04;

import com.lyd.demo03.Rent;

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);
    }

    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制实现
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String msg){
        System.out.println("执行力"+msg+"方法");
    }
}

测试的Clinet

package com.lyd.demo04;

import com.lyd.demo02.UserService;
import com.lyd.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();
    }
}

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:

11.3、使用Spring实现AoP 导入一个包！



   org.aspectj
   aspectjweaver
   1.9.4

方式一：使用spring的API接口 [主要是实现SpringAPI接口]

public class Log implements MethodBeforeAdvice {
    //method:要执行目标对象的方法
    //args:参数
    //target:目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

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);
    }
}

配置aop

测试类

public class MyTest {
    @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理实现的是接口
        UserService userService = context.getBean("userService",UserService.class);
        userService.add();

    }
}

方式二：自定义类实现AoP [主要是切面定义]

自定义类

package com.lyd.diy;

public class DiyPointCut {

    public void before(){
        System.out.println("======方法执行前======");
    }

    public void after(){
        System.out.println("======方法执行后======");
    }

}

配置aop

方式三：使用注解实现

自定义切面

package com.lyd.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.lyd.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }

    @After("execution(* com.lyd.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }

    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.lyd.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //执行方法
        Object proceed = jp.proceed();
        System.out.println("环绕后");
    }
}

配置aop

12、整合Mybatis

步骤：

导入相关jar包

junit
mybatis
mysql数据库
spring
aop织入
mybatis-spring
- mybatis-spring 官方文档

    
        
            mysql
            mysql-connector-java
            8.0.25
        
        
            org.mybatis
            mybatis
            3.5.9
        
        
            org.springframework
            spring-webmvc
            5.3.15
        
        
        
            org.springframework
            spring-jdbc
            5.3.15
        
        
            org.aspectj
            aspectjweaver
            1.9.4
        
        
        
            org.mybatis
            mybatis-spring
            2.0.7

编写配置文件
测试

12.1、回忆mybatis

编写实体类
编写核心配置文件
编写接口
编写Mapper.xml
测试

12.2、MyBatis-Spring

千万别忘了要去applicationContext.xml注册bean!!!

方式一:

编写数据源配置
sqlSessionFactory

sqlSessionTemplate

import com.lyd.mapper.UserMapper;
import com.lyd.pojo.User;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        for (User user:userMapper.selectUser()) {
            System.out.println(user);
        }

    }
}

需要给接口加实现类

package com.lyd.mapper;

import com.lyd.pojo.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper{
    //我们的所有操作，都是用SqlSessionTemplate
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public List selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

将自己写的实现类，注入到spring中
```
    

    
    
        
    
```
测试使用

    @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = (UserMapper) context.getBean("userMapper");
        for (User user:userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}

方式二：

编写数据源配置
sqlSessionFactory
sqlSessionTemplate

给接口添加实现类

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public List selectUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

测试使用

13、声明式事务 1、回顾事务

ACID原则

原子性
一致性
隔离性
持久性

2、Spring中的事务管理

声明式事务：AoP
编程式事务：需要在代码中，进行事务的管理

声明式事务

开启事务支持
```
  
```
在spring中加入aop约束和tx事务约束

配置事务通知

spring简化了

配置事务切入
```
    
    
        
        
    
```

.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”>

3. 配置事务通知

   spring简化了

   ~~~xml

配置事务切入
```
    
    
        
        
    
```

Spring

Java相关栏目本月热门文章