spring

interceptor 拦截器 introduce 介绍 parser解析器 aware 知道的 internal 内部的  decompile 反编译
threshold 阈值

 

依赖注入的三种方式（将依赖的对象放进去）：

第一种是构造方法传入依赖注入的对象。

第二种是setter方法传入依赖注入的对象。

第三种是注解的方式。反射可以修改成员变量的可见性。

 

工厂容器和applicationcontext容器

Bean的声明周期：

1、第一步实例化（通过反射四中构建方法）

2、第二部ioc注入bean和值

3、如果实现了BeanNameAware，会调用setBeanNmae方法。

 

groupid什么项目组  artifactid模块id  relativepath联系路径。

packaging 属性名pom告诉别人这就是来继承的。

最后运行的是target里面编译好的东西。

 

applicationcontext的声明周期

切面：包含那些东西，在哪里进行切入。

配置文件配置aop，获取对象的时候要转型成

 

 

配置文件中一旦启用组件扫描，就会实例化一些特殊的bean。

context：component-scan base-package=“com.demo” //那么实际上他会自动补齐为 classpath:com.demo.**.*(两个*代表递归下面的所有包)

 

只要在容器中（applicationcontext、上下文）有一个类实现了BeanPostProcessor接口，那么，在容器中的每一个bean实例化都会调用里面的postProcessBeforeInitialzation方法，然后中间可以穿插一个你在bean中的init-method方法，之后再执行after方法

----------》》

internalAutowired这个类（的对象）就实现了beanpostprocessor接口，他使用的就是这个原理，然后在每个bean被实例化之后(所有的bean)，他就会去扫描里面有没有需要自动注入的注解。@Autowired @Resource（把autowired换成common就是处理的resource注解）

--->>在上上一段之后，会调用bean中的destory的方法。可以进行一些资源的释放操作。

 

 

 

AOP：（一个类里面 的所有方法在执行前后要执行的代码抽离出来，我的理解）

一、（最原始的配置，了解）（只需要spring-aop那个包就可以了）xml配置代理对象的时候，class配置的是ProxyFactoryBean类，

然后这个类它继承了factoryBean接口（第四种实例化对象的方式）

可以通过它的getObject方法来获取到一个代理对象。

然后在代理对象里面配置被代理对象的接口、被代理对象的类，再实现一个类继承了MethodBeforeAdvice类，然后将这个类实例化也指定到代理对象的属性里面去。在这个类里面的before方法里面有三个参数，分别是Method(可以获取要切入的方法名)，object [] args（要切入方法的参数）,target

在从application里面拿对象的时候，需要将对象转型成实现的那个接口的引用类型。

 

二、（纯POJO切面）

<aop：config  proxy-target-class="">

     <aop:aspect  id=""  ref="">   这个是切面类，就是

            <aop:pointcut  id = "给这个切入点起个名字"  expression="这里面配置你要搞的表达式用来匹配要切入的方法">

                   <aop:before  method ="上面aop:aspect切面类里面的方法"    point-ref=

如果需要获取方法名字和参数，那么需要在切面类的before方法里面传入一个对象（传统的是插入三个对象）JoinPoint。

 

三、注解

三部分，一个切面类（@aspect和@component（如果开启扫描就不需要了）），然后切面类里配置方法，和切入点，然后在bean里面实例化

@pointcut("execution()") //这里面写一个表达式，用来匹配你要切入那些类的哪些方法。

public void beforepoint(){}  //这就是随便一个方法就可以，暂时没有发现作用,发现作用，在下面定义before方法切入到哪里时需要

@Before("com.demo.spring.Advice.beforePoint") //这里就是使用上面的那个方法。注解在方法上面，所以使用这个方法。在这里定义你的before方法要切入到哪个类的方法里面去。就是上面beforepoint上面注解的表达式。

 

静态代理

就是自己定义一个代理类，然后这个代理类调用被代理类的方法，然后在代理类里面有一个有一个被代理类的实例，可以在使用构造函数实例化代理类的时候，把被代理对象放进去

动态代理

jdk代理，由java内部的反射机制来实现，而cglib动态代理则是借助底层的asm的字节码工具来实现的。

cglib动态代理，有时候我们想要实现一个代理类的时候，发现被代理类已经被写好了，而且没有使用接口，怎么办？我们就可以使用cglib动态代理，就是让代理类继承被代理类，然后先写一个before然后在super.调用父类的方法。这个样子。

jdk代理，由java内部的反射机制来实现，而cglib动态代理则是借助底层的asm的字节码工具来实现的。

反射在生成类的过程中比较高效，而asm执行高效。

jdk使用的前提就是被代理类（以前的项目）已经被写好，不方便再实现统一的接口。

 

dao支撑，每种数据库链接技术的报的异常都不一样（如mybatis、jdbc等），通过spring的数据整合，让主键重复报的异常都一样。

*匹配任何数量字符。..匹配任何数量的字符重复（所有子包，在方法中则是所有参数）。

 

aop动态传入多个对象（动态 代理，两种方式），织入公共代码

传统的需要实现接口，pojo不需要实现接口。注解的方式（要注意在xml里面启用注解使用，在事务的时候也要开启。）

注意aspect要加两个注解，一个@Aspect 和 @component。

 

声明式事务，spring-tx    spring-jdbc  再来一个驱动jar包 com.core.mysql.connector,再来一个连接池。

 

连接池

jdbctemplate就是把一些打开数据连接、关闭数据库连接等的操作不用自己实现，自己只需要调用execute、update等就可以了。

使用：在xml文件中配置好之后，直接在dao层autowired就可以使用了（jdbctemplate.execute("sql语句",arg0,arg1)）

在主键重复时，使用jdbc和mybatis（jdbc的封装）抛出来的异常都不一样，

spring的dao会帮我们把异常名给统一了

 

事务如何做到的，一般是在service层做事务的，然后调用service层的代理类，在代理类里面织入环绕通知（前后），然后将Connection在service层搞一个threshold，将这个Connection放到threshold里面去。这样，就算调用多个dao层的多条sql语句（正常的话是多个connection），也使用的是同一个connection，好做事务。

 

spring-tx事务切面的配置：

首先是定义一个切点（这里面配置你再什么地方要切入事务，然后再在tx：advice里面配置刚才你切入事务 的地方里面的（我们举的例子是service层里面的方法）哪些方法你要进行什么操作（回滚主要是，我认为）），然后将一个通知引用（txadvice，我觉得这个应该就是代理类------应该不是）和切点组合起来，然后再配置通知引用，在里面配置什么（什么时候事务进行回滚） propagation:必须需要一个事务，这是事务的传播行为（以前有事务就行，没有事务就开一个），运行时异常（默认的还有error）会进行回滚。

我们把这些属性配置完之后，需要tranctionmanager来进行管理事务（在代理里面真正执行事务控制的是tranctionmanager）。

配置完这两个之后，在上面再配置一个tranctionManager的bean，里面有属性是datasource，用来开启事务。

 

使用注解进行事务控制。

 

 

 

spring-aop spring-aspects(前面那个是传统。aspect-j接口专门用于做aop编程（普通的aspect只能匹配普通方法，不能匹配构造方法）)

 

基于代理的  程序运行起来以后，动态生成代理对象。 而aspectj在编译的时候就可以进行搞好。

配置，现在xml里面实例化了相应的bean，然后配置一个aop的配置。然后再新建一个类，在上面注解component、aspect。然后在搞一个方法上面搞一个

 

切面：-------------------------------------------------------------------------------------

try{

前置通知

m1（）；

返回通知

}catch{

异常通知

}

后置通知

环绕通知（主动掉方法，然后在方法前后加前、后置通知）

切入点。链接到前置、后置？等等。

-----------------------------------------------------------------------------------------------

 

为什么要实现代理类和被代理类要实现同样的接口。 

因为你的被代理类如果想要调用代理类的方法，就必须知道它有些什么方法，就只能实现同一个接口。

 

spring的aop（动态代理模式实现的。）是基于jdk的动态代理的

1454.  上午的切面。

一种如果有接口就使用jdk自带的动态代理，另一种如果没有接口就使用cglib（ASM字节码工具）代理。

 

注解不需要进行set方法，因为他会反射修改可见性为private然后加set方法（我猜）

1610 异常捕获

1618数据库连接

为什么声明式事务要放在service层，因为有可能会有多个dao，多个数据库连接。

运行时异常，如果方法，声明抛出运行时异常

事务隔离4级别 oracle2个，mysql四个都支持。

 

不要在service层捕获异常，否则事务管理器就会接受不到异常。

result取到的是一行一行 的数据

aop（三种方式配置）和数据访问集成梳理完之后

写一个service对象。事务管理，增删改查，日志记录。

 

spring自带两种容器：一个是factorybean，一个是上下文，factory已经被抛弃了。

 

 

<!--    如果在这个里面的话，他就会被管理，不会被主动被继承，如果想在子pom文件中被使用，只能明确去声明它-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>5.2.8.RELEASE</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

 

classpathxmlapplication 配置的文件他会去哪儿找配置文件？