Spring_Java

Spring

1.Spring
- 1.1概述
- 1.2核心容器
- 1.3AOP
- - 1.3.1AOP简介
  - 1.3.2AOP入门案例
  - 1.3.3AOP工作流程
  - 1.3.4AOP切入点表达式
  - 1.3.5AOP通知类型
  - 1.3.6AOP通知获取数据
- 1.4事务
- - 1.4.1事务简介
  - 1.4.2事务角色
  - 1.4.3事务属性

1.Spring 1.1概述

1.Spring的系统架构图

1.2核心容器

1.IoC控制反转

IoC(Inversion of Control): 使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。
Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的外部
IoC容器负责对象的创建，初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

2.DI(Dependency Injection)依赖注入

在容器中建立Bean和Bean之间的依赖关系的整个过程，称为依赖注入

3.目标：充分解耦

使用IoC容器管理Bean(IoC)
在IoC容器内将有依赖关系的bean进行关系绑定(DI)

4.IoC入门案例
1.思路分析

管理什么？（Service与Dao）
如何将被管理的对象告知IoC容器？（配置）
被管理的对象交给IoC容器，如何获取到IoC容器？(接口)
IoC容器得到后，如何从容器中获取Bean？（接口方法）
使用Spring导入哪些坐标？(pom.xml)

2.导入Spring坐标


        
            org.springframework
            spring-context
            5.2.20.RELEASE

3.定义Spring管理的类

4.创建Spring配置文件，配置对应类作为Spring管理的bean

5.初始化IoC容器，通过容器获取bean

@Test
    public void Demo03() {
        //获取IoC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取bean
        BookServiceImpl bookServiceImpl = context.getBean("bookServiceImpl", BookServiceImpl.class);
        bookServiceImpl.save();
    }

5.DI入门案例
1.思路分析

基于IoC管理bean
Service中使用new形式创建的Dao对象是否保留(否)
Service中需要的Dao对象如何进入到Service中？(提供方法)
Service与Dao间的关系如何描述？(配置)

2.删除使用new的形式创建对象的代码并提供set方法

public class BookServiceImpl implements BookService {
    private BookDaoImpl bookDao;

    public void setBookDao(BookDaoImpl bookDao) {
        this.bookDao = bookDao;
    }

    public void save(){
        System.out.println("book service ");
        bookDao.save();
    }
}

3.配置Service与Dao之间的关系

6.bean基础配置
1.bean基础配置
2.bean别名的配置
3.bean作用范围(bean创建时实例的数量)的配置

在bean标签中使用scope属性，值为singleton: 单例，prototype：非单例

7.bean实例化
1.bean是如何创建出来的

2.bean实例化的三种形式
①无参构造函数
②静态工厂(了解）
③实例工厂(了解)

FactoryBean（常用）

3.FactoryBean（常用）步骤

创建以下类和接口

public interface UserDao {
     public void save();
  }
  
public class UserDaoImpl  implements UserDao{
   public void save() {
       System.out.println("user dao save ...");
   }
}

//实现接口FactoryBean
public class UserDaoFactoryBean implements FactoryBean {
   //代替原始实例工厂中创建对象的方法
   public UserDao getObject() throws Exception {
       return new UserDaoImpl();
   }
   //返回所创建类的Class对象
   public Class getObjectType() {
       return UserDao.class;
   }
  //返回实例对象的个数(true:单例  )
   @Override
   public boolean isSingleton() {
       return false;
   }
}

2.配置文件

3.测试

@Test
    public void test02(){
        ApplicationContext ctx = new
                ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDao) ctx.getBean("userDao");
        UserDao userDao2 = (UserDao) ctx.getBean("userDao");
        System.out.println(userDao1);
        System.out.println(userDao2);

        userDao1.save();

    }

8.bean的生命周期
1.生命周期：从创建到消亡的完整过程
2.bean生命周期：bean从创建到消亡的完整过程
3.bean生命周期控制：在bean创建后到销毁前做一些事情

(1)关于Spring中对bean生命周期控制提供了两种方式:

在配置文件中的bean标签中添加init-method和destroy-method属性
类实现InitializingBean与DisposableBean接口，这种方式了解下即可。

(2)关闭容器的两种方式:

ConfigurableApplicationContext是ApplicationContext的子类
- close()方法
- registerShutdownHook()方法

9.setter注入
10.构造器注入
11.自动装配
12.集合注入
注解开发内容
···············
以上内容已经学过不在这记笔记了

1.3AOP 1.3.1AOP简介

1.AOP概念与作用

AOP:面向切面编程，一种编程范式，指导开发者任何组织程序结构
作用：在不惊动原始设计的基础上为其进行功能的增强
Spring理念：无入侵式/无侵入式编程

2.AOP核心概念

连接点：程序执行过程中的任意位置，粒度为执行方法，抛出异常，设置变量等(在SpringAOP中，理解为方法的执行)
切入点：匹配连接点的式子(在SpringAOP中，一个切入点可以只描述一个方法，也可以匹配多个方法)
通知：在切入点处执行的操作，也就是共性操作(在SpringAOP中，功能最终已方法的形式呈现)
通知类：定义通知的类
切面：描述通知与切入点之间的对应关系

1.3.2AOP入门案例

1.先创建一个基本的环境

2.导入依赖

   
      org.aspectj
      aspectjweaver
      1.9.4

3.定义通知类,切入点，切面

@Component//告诉Spring来加载我
@Aspect//告诉Spring这个东西是用来做AOP的
//通知类
public class MyAdvice {
    //切入点
    @Pointcut("execution(void com.it.dao.BookDao.update())")
    private void pt(){}
    

    //在切入点的什么位置执行
    @Before("pt()")//切面
    //通知,共性功能
    public void method(){
        System.out.println(System.currentTimeMillis());
    }

}

4.开启Spring对AOP注解驱动支持

@Configuration
@ComponentScan("com.it")
@EnableAspectJAutoProxy//告诉Spring项目里面用注解开发的AOP
public class SpringConfig {

}

1.3.3AOP工作流程

1.Spring容器启动
2.读取所有切面配置中的切入点
3.初始化bean, 判定bean对应的类中的方法是否匹配到任意切入点

匹配失败，创建对象
匹配成功，创建原始对象的代理对象

4.获取bean执行方法

获取bean,调用方法并执行，完成操作
获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

1.3.4AOP切入点表达式

1.切入点：要进行增强的方法
2.切入表达式：要进行增强的方法的描述方式
描述方式一：执行包下接口中的无参update方法(这种，接口的所有实现类的此方法都可以连接到通知)
描述方式二：执行包下实现类中的无参update方法

1.语法格式

标准格式：动作关键字（访问修饰符返回值包名.类/接口名.方法名(参数) 异常名）
动作关键字：描述切入点的行为动作，例如：execution表示执行到指定切入点
访问修饰符，异常名可以省略
execution(void com.it.dao.BookDao.update())

2.通配符

*：单个独立的任意符号，可以独立出现，也可以作为前缀或后缀的匹配符出现
:多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
+ ：专用于匹配子类类型

3.书写技巧

1.3.5AOP通知类型

1.AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同。最终运行代码时要将其加入到合理的位置
2.AOP通知共分为五种类型

前置通知@Before
后置通知@After
环绕通知(重要)@Arount
返回后通知(了解)@AfterReturning
抛出异常后通知(了解)@AfterThrowing

1.3.6AOP通知获取数据

1.获取参数(重点)

都可以获取参数
环绕通知：使用ProceedingJoinPoint pjp 形参
其它：使用JoinPoint jp 形参

@Before("pt()")
    public void before(JoinPoint jp) {
        //获取参数
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        
        System.out.println("before advice ..." );
    }
@Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        //获取形参
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        
        Object ret = pjp.proceed();
        return ret;
    }

2.获取返回值

只有环绕通知，返回后通知

@Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        //获取形参
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        //获取返回值
        Object ret = pjp.proceed();
        return ret;
    }
    //获取返回值
    @AfterReturning(value = "pt()",returning = "obj")
    public void afterReturning(JoinPoint jp,Object obj) { //一定是JoinPoint jp在第一个形参位置
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("afterReturning advice ..." + obj);
    }

3.获取异常(了解)

只有环绕通知，抛出异常后通知

@Around("pt()")
    public Object around(ProceedingJoinPoint pjp){
        //获取形参
        Object[] args = pjp.getArgs();
        System.out.println(Arrays.toString(args));
        //获取返回值
        Object ret = null;
        //获取异常
        try {
            ret = pjp.proceed();
        } catch (Throwable e) {
            System.out.println(e);
        }
        return ret;
    }
    
@AfterThrowing(value = "pt()",throwing = "t")
    public void afterThrowing(JoinPoint jp,Throwable t) {
        Object[] args = jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("afterThrowing advice ..." + t);
    }

1.4事务 1.4.1事务简介

1.事务作用：在数据层保障一系列的数据库操作同成功同失败
2.Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败
3.实现事务的步骤：

①在业务层接口上添加Spring事务管理(@Transactional)
②设置事务管理器
③开启注解式事务驱动(@EnableTransactionManagement)

1.4.2事务角色

1.事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法

2.事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

1.4.3事务属性

1.事务配置

2.事务传播行为

概述：事务协调员对事务管理员所携带事务的态度
使用@Transactional(propagation= Propagation.值)

Spring

Java相关栏目本月热门文章