学习Spring

1. 介绍

Spring介绍

• 学习视频：https://www.bilibili.com/vide...
• Rod Johnson是Spring Framework的创始人。Spring的理念：使Java企业级开发更加简单
• 官网：https://spring.io/projects/sp...
• 优点：一个开源的免费的容器（框架），其==最重要的特点是IOC,AOP,和支持事务的处理（面试被问到过）==
• 依赖包：使用spring-webmvc可以导入学习的所有依赖包

    org.springframework
    spring-webmvc
    5.2.0.RELEASE



    org.springframework
    spring-jdbc
    5.2.5.RELEASE

Spring组成（面试）

学习：https://blog.csdn.net/qq_4277...

• Spring Core：Core包是框架的最基础部分，并提供依赖注入（Dependency Injection）管理Bean容器功能
• Spring Context：Core模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。这个模块扩展了BeanFactory的概念，增加了对国际化（I18N）消息、事件传播以及验证的支持。另外，这个模块提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括了对模版框架例如Velocity和FreeMarker集成的支持。
• Spring AOP：Spring在它的AOP模块中提供了对面向切面编程的丰富支持。例如方法拦截器（method-interceptors）和切点（pointcuts），可以有效的防止代码上功能的耦合，这个模块是在Spring应用中实现切面编程的基础。
• Spring DAO：对JDBC进行了抽象，大大简化了数据库访问等繁琐的操作；
• Spring ORM：关系映射模块，ORM包为流行的“关系/对象”映射APIs提供了集成层，包括JDO，Hibernate和iBatis（MyBatis）。通过ORM包，可以混合使用所有Spring提供的特性进行“对象/关系”映射，方便开发时小组内整合代码。
• Spring Web：Web上下文模块建立于应用上下文模块之上，提供了一个适合于Web应用的上下文。另外，这个模块还提供了一些面向服务支持。利用Servlet listeners进行IOC容器初始化和针Webapplicationcontext。
• Spring MVC：提供面向Web应用的Model-View-Controller实现。

Spring后续框架

• Spring Boot

  • 一个快速的脚手架，基于SpringBoot可以快速的开发单个微服务
  • 特点：约束>配置

• Spring Cloud

  • 基于SpringBoot实现的完整的微服务开发，是目前的主流
  • 特点：完整的微服务框架

2 IOC

IOC的推导

• 之前的Web工程需要Dao，DaoImpl，Service，ServiceImpl，Controller实现应用，但如果代码量过大，变更需求过多，修改一次代码需要更改关联的更多代码，成本十分昂贵
• 假设，我们不在代码中=new XXimpl，而是通过接口的set方法设值，让程序员不用再去管理对象的创建
• 于是，使用了set注入后，程序不再具有主动权，而是变成了被动接受的对象=IOC原型
• 明确概念：IOC是一种思想，DI（依赖注入）是IOC的实现的一种方式，两者不完全相同

初试application

• import:多人开发，导入多个application配置文件
• bean：创建对象
• alias：取对象的别名，但在bean中直接使用name=XX，比单独使用alias更推荐使用

构造器注入

默认是使用无参构造创建bean

如果没有无参构造，就必须使用< constructor-arg />指定构造器

总结：在配置文件里面注册bean的时候，就已经实例化了

属性注入

原理：通过Setter方法注入的。同时明白什么DI（依赖注入的概念）

依赖：bean的对象创建依赖于Spring容器来实现

注入：bean对象的所有属性由Spring容器来注入

application.xml

• 学习各种基本类型，引用类型注入，扩展补充：p命令，c命令简化注入（需要导入约束），但使用的很少

    
    
        
    
    
    
        
        
        
        
        
        
            
                红楼梦
                西游记
                三国演义
            
        
        
        
            
                学习
                打球
                听歌
            
        
        
        
            
        
        
        
            
                LOL
                BOB
            
        
        
        
            
        
        
        
            
                www.baidu.com
                123456
            
        
    
    
    
    
    

Java配置application

• 普通开发很少使用，但是各种框架源码大量使用

@Configuration
public class MyConfig {
    /**
     *    方法名= bean id ；返回值=bean 的class
     */
    @Bean
    public User beanId() {
        return new User();
    }
}
@Component
public class User {
    @Value("张三")
    private  String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

作用域

Scope	Description
singleton	(默认)为每个Spring IoC容器将单个bean定义作用于单个对象实例。
prototype	每个bean都产生一个新的对象实例
request	将单个bean定义的范围限定为单个HTTP请求的生命周期。也就是说，每个HTTP请求都有自己的bean实例，这些实例是在单个bean定义的基础上创建的。仅在web感知的Spring“ApplicationContext”的上下文中有效。
session	将单个bean定义定义为HTTP“会话”的生命周期。仅在web感知的Spring“ApplicationContext”的上下文中有效。
application	将单个bean定义的范围扩展到“ServletContext”的生命周期。仅在web感知的Spring“ApplicationContext”的上下文中有效。
websocket	将单个bean定义的范围扩展到“WebSocket”的生命周期。仅在web感知的Spring“ApplicationContext”的上下文中有效。

自动装配

• 不用显示配置bean，添加约束后，Spring会在上下文中自动寻找，并自动给bean装配属性

• 三种装配方式

  • xml中显示装配
  • 自动装配
  • java装配：=前面的 “Java配置application”

bean中的自动装配

• byName：bean的id = 自动注入的成员属性setXXX一样

• byType：bean中的class和成员变量的类型一致

注解实现自动装配

• 导入注解约束

• @Autowired+@Qualifier=@Resource(name = “xx”)

1. 使用：直接在成员属性上使用，也可以在set上使用
2. 原理：通过反射去xml中寻找成员类型 = class的bean，并自动装配；
3. 默认装配不能为空：可以使用@Autowired(required = false)指定为空
4. 多个相同bean的class：使用@Qualifier(value = "dog1")

5. @Autowired+@Qualifier=@Resource(name = “xx”)区别

   1. 相同点：都是自动装配配置
   2. 不同点：@Autowired+@Qualifier通过byType=class来查找；@Resource(name = “xx”)默认通过byname=id来查找，如果没找到，接着用byType=class来查找

注解开发

导入aop包

     org.springframework
     spring-aop
     5.2.5.RELEASE

导入xml配置

• 注解配置+指定扫描包

@Component和@Value

• 注解注入bean组件：@Component,不用手动去xml中配置bean

  • component三大衍生注解

    • @Repository：对应dao层
    • @Service：对应service层
    • @Controller：对应controller层
• 注入成员属性：@Value("张三")
• 作用域：@Scope(value="prototype")

/*
    @Component = 
    @Value("张三") = 通过setter方法区赋值
 */
@Component
@Scope(value = "prototype")
public class User {

    @Value("张三")
    private  String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

xml配置和注解开发

• xml：用来配置Spring一些需求，但bean使用注解配置
• 注解：只负责完成bean的创建和属性的注入

3 代理模式

1 静态代理

2 动态代理

• 动态代理分为：1 基于接口的；2 基于类的动态代理

  • 基于接口的：JDK动态代理
  • 基于类的的：cglib
  • 基于java字节码：Javasist
• 学习两个类：Proxy；InvocationHandler(调用处理器)

//学习动态代理类的实现
public class ProxyInva implements InvocationHandler {
    //1 实现被代理的接口
    private Rent rent;
    public void setRent(Rent rent) {
        this.rent = rent;
    }
    //2 获得代理对象,通过Proxy.newProxyInstance
    public Object getProxy() {
        return Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),
                this);
    }
    //3 处理代理对象，被返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        beforeSee();
        //激活被代理角色的行为
        Object invoke = method.invoke(rent, args);
        afterSee();
        return  invoke;
    }
    //动态代理原型：在invoke前后添加的方法就是aop原型
    public void beforeSee(){
        System.out.println("提前看房");
    }

    public void afterSee(){
        System.out.println("过后看房");
    }
}
//动态代理模版
public class ProxyInvaObject implements InvocationHandler {
    //1 创建抽象接口，需要set方法实现反射
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //2 代理方法，Spring自动实现中介角色
    public Object getProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    //3 实现抽象接口的实体方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        addMethod(method.getName());//反射的强大之处
        //方法.invoke(接口名，参数)
        return method.invoke(target, args);
    }
    //4 添加的功能，学习反射的强大之处
    private void addMethod(String msg) {
        System.out.println("执行了" + msg + "方法");
    }
}

//动态代理的调用
public class Client {
    public static void main(String[] args) {
        //真实角色
        Rent host = new Host();
        //代理角色
        ProxyInva proxyInva = new ProxyInva();
        //代理角色设置真实角色实现的抽象接口
        proxyInva.setRent(host);
        //代理角色获得Rent代理类
        Rent proxy = (Rent) proxyInva.getProxy();
        //由proxy动态代理调用被代理的接口方法
        proxy.rent();
    }
}

4 AOP

原理图

• aop：不改变原有代码情况下，增加一些功能
• 原理图：各种名词请反复看

Spring实现AOP

• 方式一：无需切面，直接实现InvocationHandler接口
• 方式二：自定义切面，其中编写需要的通知方法
• 方式三：注解配置切面，使用@Aspect

    org.aspectj
    aspectjweaver
    1.8.13

//aop配置1：方法前通知=MethodBeforeAdvice
public class beforeLog implements MethodBeforeAdvice {
    /**
     *
     * 前置增加日志功能
     * @param method 被aop增强的方法
     * @param args   method形参
     * @param target method所在的类
     */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        String targetName = target.getClass().getName();
        String methodName = method.getName();
        System.out.println(targetName + ":的[" + methodName + "]方法被执行了");
    }
}

//aop配置2
public class DiyPointCut {
    public void before() {
        System.out.println("=====方法前=====");
    }

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

//aop配置3：注解定义切面
@Aspect
public class AnonPointCut {
    //切入点1
    @Before("execution(* service.UserServiceImpl3.*(..))")
    public void before() {
        System.out.println("Anon=====方法前=====");
    }
    //切入点2
    @After("execution(* service.UserServiceImpl3.*(..))")
    public void after() { System.out.println("Anon=====方法后=====");
    }
    //环绕通知
    @Around("execution(* service.UserServiceImpl3.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕前");
        joinPoint.proceed();
        System.out.println("环绕后");
        /*
            环绕前
            Anon=====方法前=====
            增加了一个用户
            环绕后
            Anon=====方法后=====
         */
    }
}

5 原生Mybatis回顾

步骤：

• mybatis-config.xml
• 配置文件
• 测试

1 依赖包

    
        root
        com.ssl
        1.0-SNAPSHOT
    
    4.0.0

    com.ssl
    mybatis-spring
    1.0-SNAPSHOT

    
        
        
            junit
            junit
            4.13
        
        
        
            mysql
            mysql-connector-java
            5.1.48
        
        
        
            org.springframework
            spring-jdbc
            5.2.5.RELEASE
        
        
        
            org.mybatis
            mybatis
            3.5.4
        
        
        
            org.mybatis
            mybatis-spring
            2.0.4
        
        
        
            org.springframework
            spring-web
            5.2.5.RELEASE
        
        
        
            org.aspectj
            aspectjweaver
            1.9.5
        
        
        
            org.projectlombok
            lombok
            1.18.12
        
    
    
    
        
            
                src/main/java
                
                    **/*.xml
                
                true
            
        
    

2 配置文件

1. 编写实体类

@Data
public class User {
    private int id;
    private String name;
    private String pwd;
}

1. mybatis-config.xml

1. 编写接口和mapper.xml

public interface UserMapper {
    public List getUsers();
}

    
        select * from mybatis.user;
    

3 测试

spring-mybatis就是简化了这个配置，但是原理没变

public class MyTest {
    @Test
    public void getUsers() throws IOException {
        String resources = "mybaits-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resources);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List users = userMapper.getUsers();
        System.out.println(users);
    }
}

6 Mybatis-Spring

• 概念：MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。最终，可以做到应用代码不依赖于 MyBatis，Spring 或 MyBatis-Spring。

实现一：

• 在Spring中配置dataSource、sqlSessionFactory、sqlSessionTemplate

• spring-dao.xml和apllication.xml

• 实现类注入sqlSession

public class UserMapperImpl implements UserMapper {

    private SqlSessionTemplate sqlSessionTemplate;

    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

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

实现二：

• spring-dao,xml可以减少sqlSessionTemplate配置，通过实现类中继承extends SqlSessionDaoSupport

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

• application.xml

测试

public class MyTest {
    @Test
    public void getUsers2() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
        List users = userMapper.getUsers();
        System.out.println(users);
    }
    @Test
    public void getUsers3() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserMapper userMapper = context.getBean("userMapperImpl2", UserMapper.class);
        List users = userMapper.getUsers();
        System.out.println(users);
    }
}

7 事务

• 概念：就一句话，要么都成功，要么都失败；在项目中十分重要，确报项目的完整性和一致性

ACID原则（面试高频）

• 原子性：
• 一致性：一个事务前后数据一致。无论怎么转账，总数1000不会变
• 隔离性：多个业务操作同一个资源，防止数据损坏
• 持久性：事务一旦提交，无论系统发生什么问题，结果都不会改变，被持久化进数据库中

Spring中的事务管理

• 声明式事务：AOP注入
• 编程式事务：需要改变原有代码，在源码上增加try-catch-final

实现声明式事务

7种事务传播（面试高频）

学习：https://blog.csdn.net/soonfly...

名称	特性
required（默认）	支持当前事务，如果没有事务，就新建一个事务
support	支持当前事务，如果没有事务，就不执行事务
mandatory	支持当前事务，如果没有事务，就抛出异常
required_new	新建事务，如果当前有事务，就将当前事务挂起
not_supported	以非当前事务执行操作，如果当前有事务，就将当前事务挂起
never	以非当前事务执行操作，如果当前有事务，就抛出异常
nested	支持当前事务，如果当前事务存在，则实行一个嵌套事务，如果没有事务，就新建一个事务

xml配置事务

接口配置

public interface UserMapper {
    public List getUsers();
    public int addUser(User user);
    public int deleteUser(int id);
}

mappper.xml配置

• 删除操作，手动模拟失败

    
        select * from mybatis.user;
    
    
    
        insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{pwd});
    
    
    
        deletes from mybatis.user where id=#{id}
    

实现接口

public class UserMapperImpl implements UserMapper {

    private SqlSessionTemplate sqlSessionTemplate;

    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }

    @Override
    public List getUsers() {
        User user = new User(5, "小宋", "123456");
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        //模拟一组添加和删除的操作，保证两个操作同时成功，不能单独一个操作成功；
        //但是删除操作的sql语句故意写错
        mapper.addUser(user);
        mapper.deleteUser(user.getId());
        return mapper.getUsers();
    }

    @Override
    public int addUser(User user) {
        return sqlSessionTemplate.getMapper(UserMapper.class).addUser(user);
    }

    @Override
    public int deleteUser(int id) {
        return sqlSessionTemplate.getMapper(UserMapper.class).deleteUser(id);
    }
}

测试

• 删除操作肯定失败，查看数据库是否添加成功；没有添加成功=事务开启成功

public class MyTest {
    @Test
    public void getUsers2() throws IOException {
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        UserMapper userMapper = context.getBean("userMapperImpl", UserMapper.class);
        List users = userMapper.getUsers();
        System.out.println(users);
    }
}

8 Spring重点

• 注解开发
• Aop配置和反射
• 声明式事务开启
• 整合Mybatis和MVC