Spring笔记

Spring

       ioc的概念和作用

IOC将创建对象的控制权，由对象本身转交由Bean容器，根据配置文件去加载创建
实例，并管理各个实例之间的依赖关系。

控制反转:把创建对象的权力交给框架。
作用:消减计算机程序的耦合(解除代码中的依赖关系)

Dao.IMPL文件下:
IAccountDao接口:
public interface IAccountDao {
void saveAccount();
}
AccountDaoImpl类:
public class AccountDaoImpl implements IAccountDao {
@Override
public void saveAccount() {
System.out.println(“保存了账户”);
}
}
Service.IMPL文件下:
IAccountService接口:

/*
账户业务层接口
*/

public interface IAccountService {
void saveAccount();
}
AccountServiceImpl类:
public class AccountServiceImpl implements IAccountService {
private IAccountDao accountDao=new AccountDaoImpl();
//private IAccountDao accountDao= (IAccountDao) BeanFactory.getBean(“accountDao”);
@Override
public void saveAccount() {
accountDao.saveAccount();
}
}
CLIENT类:
//模拟一个表现层，用于调用业务层
//获取spring中的IOC容器，根据id获取对象
public class Client {
/*

 */
public static void main(String[] args) {
    //获取核心容器对象
    ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
    //根据id获取bean对象 :两种方法
    IAccountService as= (IAccountService) ac.getBean("accountService");
    IAccountDao adao=ac.getBean("accountDao",IAccountDao.class);
    System.out.println(as);
    System.out.println(adao);
    as.saveAccount();
}

}
bean.xml文件:



ApplicationContext的三个常用实现类:
ClassPathXmlApplicationContext:可以加载类路径下的配置文件
FileSystemApplicationContext:可以加载磁盘任意路径下的配置文件
AnnotationConfigApplicationContext:是用于读取注解创建容器的
ApplicationContext: 适合单例对象使用
它在构建核心容器时，创建对象采取的策略是采用立即加载的方式，也就是说，只要一读取完配置
文件马上就创建配置文件马上就创建配置文件中配置的对象
BeanFactory: 适合多例对象使用
它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取
对象了，什么时候真正的创建对象

---

     Spring对bean的管理细节

1.创建bean的三种方式

1. 使用默认构造函数创建
   在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
   采用的就是默认构造函数来创建bean对象，此时如果类中没有默认构造函数，则对象无法创建(报错)
   

2. 使用普通工厂中的方法创建对象 （使用某个类中的方法创建对象，并存入spring容器）
   相当于是先实例化了一个工厂，然后调用工厂的创建对象的方法
   

3. 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象,并存入spring容器）
   因为是静态方法，所以无需实例化工厂，因此省略了第一个标签
   

2.bean对象的作用范围
bean的作用范围调整
bean标签的scope属性：
作用:用于指定bean的作用范围
取值:
singleton:单例的（默认值） //创建单例对象
prototype:多例的(需要scope中指明) //创建多例对象
request:作用于web应用的请求范围
session:作用于web应用的会话范围
global-session:作用于集群环境的会话范围(全局会话范围),当不是集群环境时,就是session

3.bean对象的生命周期
单例对象:
出生:当容器创建时对象出生
活着:只要容器还在，对象一直活着
死亡:容器销毁，对象消亡
总结:单例对象的生命周期和容器相同
多例对象:
出生:当我们使用对象时，spring框架为我们创建
活着:对象只要是在使用过程中就一直活着
死亡:当对象长时间不用，且没有别的对象引用时，由java的垃圾回收器回收
例子：
<bean id=“accountService” class=“com.myren.service.impl.AccountServiceImpl”

scope=“singleton” init-method=“init” destroy-method=“destroy” >

public static void main(String[] args) {

//获取核心容器对象
ClassPathXmlApplicationContext ac= new ClassPathXmlApplicationContext(“bean.xml”);
IAccountService as1= (IAccountService) ac.getBean(“accountService”);
//System.out.println(as1);
as1.saveAccount();
//手动关闭容器
ac.close();
}
单例：
创建了对象
对象初始化了
service中的saveAccount方法执行了
对象销毁了
多例：
创建了对象
对象初始化了
service中的saveAccount方法执行了

---

        spring的依赖注入
依赖注入：
   Dependency Injection

IOC的作用：
降低程序间的耦合（依赖关系）
依赖关系的管理：
以后都交给spring来维护
在当前类需要用到其他类的对象，有spring为我们提供，我们只需要在配置文件中说明
依赖关系的维护：
就称之为依赖注入
依赖注入：
能注入的数据，有三类：
基本类型和String
其他bean类型（在配置文件中或者注解配置过的bean）
复杂类型/集合类型
注入的方式，三种：
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供

构造函数注入:
使用的标签：constructor-arg
标签出现的位置：bean标签的内部
标签中的属性:
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个火某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置是从0开始
name：用于指定给构造函数中指定名称的参数赋值 常用的
以上三个用于指定给构造函数中哪个参数赋值====
value：用于提高基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象（引用关联的bean对象
优势：
在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功
弊端：
改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。
例子:

set方法注入: 更常用的方式
涉及的标签：property
出现的位置：bean标签的内部
标签的属性
name：用于指定注入时所调用的set方法名称 常用的
value：用于提高基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象（引用关联的bean对象
优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行
例子:

复杂/集合类型的注入
用于给List结构集合注入的标签：
list array set
用于给Map集合注入的标签：
map props
结构相同，标签可以相同



AAA
BBB
CCC




AAA
BBB
CCC




AAA
BBB
CCC







ccc
ddd

---

        spring基于注解的Ioc以及Ioc实例

首先:
告知spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，而是一个名称为
context名称空间和约束中

<context:component-scan base-package=“com.myren”></context:component-scan>//会扫描com.myren下的包中的bean，否则会报错

用于创建对象的：

他们的作用就和在XML配置文件中编写一个标签实现的功能是一样的
@Component：
作用：用于把当前类对象存入spring容器中 (key,value)
属性：
是value，用于指定bean的id，当我们不写时，他的默认值是当前类名，且首字母改小写
-@Controller：一般用于表现层
-@Service：一般用于业务层
-@Repository：一般用于持久层

以上三个注解他们的作用和属性与Component是一模一样的，
他们三个是spring为我们提供明确的三层使用的注解，使我们的三层对象更加清晰

用于注入数据的：

他们的作用就何在XML配置文件中的bean标签中写一个标签的作用是一样的
@Autowired:
作用：自动按照类型注入，只要容器中有唯一的一个bean对象（数据）类型和要注入的变量类型匹配，就可以注入成功
如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错
如果ioc容器中有相同的bean对象类型，则spring会先把它们圈起来，在按照变量名称查询
（private IAccountDao accountDao = null;
访问修饰符 数据类型 变量名称 数据类型)
出现位置：
可以是变量上，也可以是方法上
细节：
在使用注解注入时，set方法就不是必须的了
@Qualifier:
作用：在按照类中注入的基础之上再按照名称注入，它在给类成员注入时不能单独使用，但是在给方法参数注入时可以
属性：
name：用于指定注入bean的id
@Resource
作用：直接按照bean的id注入，它可以独立使用
以上三个注入都只能注入其他bean类型的数据，而基本类型和string类型无法使用上述注解实现
另外，集合类型的注入只能通过xml来实现
@Value
作用：用于注入基本类型和String类型的数据
属性：
value：用于指定数据的值。它可以使用spring中SpEl（也就是spring中的el表达式）
SpEL的写法：${表达式}

---

用于改变作用范围的:

他们的作用集合在bean标签中使用scope属性实现的功能是一样的
@Scope
作用：用于指定bean的作用范围
属性：
value：指定范围的取值，常用取值：singleton prototype

和生命周期相关:

他们的作用就和在bean标签中使用init-method和destroy-method的作用是一样的
@PreDestroy
作用：用于指定销毁方法
@PostConstruct
作用：用于指定初始化方法

---

       Spring的一些新注解：

@Configuration
作用：指定当前类是一个配置类

@ComponentScan
作用：用于通过注解指定spring在创建容器时要扫描的包
属性：
value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包
我们使用此注解就等同于在xml中配置了：
<context:component-scan base-package=“com.myren”></context:component-scan>
@Bean
作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，此注解可以不写
属性：
name：用于指定bean的id，当不写时，默认值为当前方法的名称
细节：
当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象
查找的方式和Autowired注解的作用是一样的
@import
作用：用于导入其他的配置类

@Configuration
@ComponentScan(“com.myren”)

public class SpringConfiguration {
//用于创建一个QueryRunner对象
@Bean(name = “runner”)
@Scope(“prototype”)
public QueryRunner createQueryRunner(DataSource dataSource){
return new QueryRunner(dataSource);
}
//创建数据源对象
@Bean(name=“dataSource”)
public DataSource createDataSource() throws PropertyVetoException {
ComboPooledDataSource ds=new ComboPooledDataSource();
ds.setDriverClass(“com.mysql.jdbc.Driver”);
ds.setJdbcUrl(“jdbc:mysql://localhost:3306/db2”);
ds.setUser(“root”);
ds.setPassword(“root”);
return ds;
}
}

细节：ApplicationContext ac=new AnnotationConfigApplicationContext(SpringConfiguration.class);
//若是传入了字节码SpringConfiguration.class,则可以把@Configuration去掉

---

@import
作用：用于导入其他的配置类
属性：
value：用于指定其他配置类的字节码
当我们使用import注解之后，有Import注解的类就是父配置类，而导入的都是子配置类
@PropertySource
作用：用于指定properties文件的位置
属性：
value：指定文件的名称和路径
关键字：classpath，表示在路径下
例子：
@Import(JdbcConfig.class)
@PropertySource(“classpath:jdbcConfig.properties”)

---

/*
使用Junit单元测试，测试我们的配置
Spring整合junit的配置
1、导入spring整合的junit的jar（坐标）
2、使用junit提供的一个注解把原有的main方法替换了，替换成spring提供的
@Runwith
3、告知spring的运行器，spring和ioc创建是基于xml还是注解的
@ContextConfiguration
location:指定xml文件的位置，加上classpath关键字，表示在类路径下
classes：指定注解类所在的配置
*/

动态代理：
特点：字节码随用随加载
作用：不修改源码的基础上，对方法增强
分类：
基于接口的动态代理
基于子类的动态代理

基于接口的动态代理：
涉及的类：Proxy
提供者：JDK官方
如何创建代理对象：
使用Proxy类中的newProxyInstance方法
创建代理对象的要求：
被代理类最少实现一个接口，如果没有则不能使用
newProxyInstance方法的参数：
ClassLoader：类加载器
他是用来加载代理对象字节码的，和被代理对象使用相同的类加载器，固定写法（代理谁，写谁的 .class.getClassLoader()）
Class[]：字节码数组
他是用于让代理对象和被代理对象有相同的方法，固定写法
InvocationHandler
他是让我们写如何代理，我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的
此接口的实现类都是谁用谁写

基于子类的动态代理：
涉及的类：Enhancer
提供者：第三方cglib库
如何创建代理对象：
使用Enhancer类中的create方法
创建代理对象的要求：
被代理类不能是最终类
create方法的参数：
Class：字节码
他是用于指定被代理对象的字节码

 Callback：用于提供增强的代码
   他是让我们写如何代理，我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的
   此接口的实现类都是谁用谁写
   我们一般写的都是该接口的子接口实现类：MethodInterceptor

---

spring中基于xml的AOP配置步骤

1.把通知Bean也交给spring来管理
2.使用aop:config标签表明开始AOP配置
3.使用aop:aspect标签表明配置切面
id属性：给切面提供一个唯一标识
ref属性：是指定通知类bean的id
4.在aop:aspect标签的内部使用对应标签来配置通知的类型
我们现在示例是让printLog方法在切入点方法执行之前执行，所以是前置通知
使用：aop:before：表示配置前置通知
method属性：用于指定Logger类中哪个方法是前置通知
pointcut属性：用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
切入点表达式的写法：
关键字：execution（表达式）
表达式：
访问修饰符 返回值 包名.包名.包名.包名…类名.方法名（参数列表）
标准的表达式写法：
public void com.myren.service.impl.AccountServiceImpl.saveAccount()
访问修饰符可以省略
void com.myren.service.impl.AccountServiceImpl.saveAccount()
返回值可以使用通配符，表示任意返回值
* com.myren.service.impl.AccountServiceImpl.saveAccount()
包名可以使用通配符，表示任意包，但是有几级包，就需要写几个*.
* ....AccountServiceImpl.saveAccount()
包名可以使用…表示当前包及其子包
* …AccountServiceImpl.saveAccount()
类名和方法名都可以使用来实现通配
* ….saveAccount()
* ….() //没有参数的都被增强了，而有参数的没有
参数列表：
可以直接写数据类型：
基本类型直接写名称 int
引用类型写包名，类名的方式 java.lang.String
可以使用通配符表示任意类型，但是必须有参数
可以使用…表示有无参数均可，有参数可以是任意一类型
全通配写法：
* ….(…)
实际开发中切入点表达式的通常写法：
切到业务层实现类下的所有方法
* com.myren.service.impl..(…)
例子：

aop:config

<aop:aspect id=“logAdvice” ref=“logger”>

<aop:before method=“printLog” pointcut=“execution(* ….*(…))”></aop:before>
</aop:aspect>
</aop:config>

---

前置通知，在切入点方法执行之前执行
后置通知，在切入点方法正常执行之后执行，它和异常通知只能执行一个
异常通知，在切入点方法执行产生异常之后执行
最终通知，无论切入点方法是否正常执行他都会在其后面执行
例子：
aop:config
<aop:aspect id=“logAdvice” ref=“logger”>
<aop:before method=“beforeprintLog” pointcut=“execution(* com.myren.service.impl.AccountServiceImpl.(…))"></aop:before>
<aop:after-returning method=“afterReturnprintLog” pointcut="execution( com.myren.service.impl.AccountServiceImpl.(…))">aop:after-returning
<aop:after-throwing method=“afterThrowingPrintLog” pointcut="execution( com.myren.service.impl.AccountServiceImpl.(…))”></aop:after-throwing>
<aop:after method=“afterPrintLog” pointcut=“execution(* com.myren.service.impl.AccountServiceImpl.*(…))”></aop:after>
</aop:aspect>
</aop:config>

环绕通知:

问题：
当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了
分析：
通过对比动态代理中的环绕通知代码，发现动态代理中的环绕通知有明确的业务层切入点方法调用，而我们的代码中没有
解决：
Spring框架为我们提供了一个接口，ProceedingJoinPoint，该接口有一个方法proceed（），此方法就相当于明确调用切入点方法
该接口可以为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类为我们使用
Spring中的环绕通知：
它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式

aop:config

<!--配置切面-->
<aop:aspect id="logAdvice" ref="logger">
    <aop:pointcut id="pt1" expression="execution(* com.myren.service.impl.AccountServiceImpl.*(..))"/>
    <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
</aop:aspect>

</aop:config>

例子:
public Object aroundPrintLog(ProceedingJoinPoint pjp){
Object rtValue=null;

try {
    Object []args=pjp.getArgs();//得到方法执行所需的参数
    System.out.println("Logger类中aroundPrintLog方法开始记录日志了...前置");
    rtValue=pjp.proceed(args);//明确调用业务层方法（切入点方法）
    System.out.println("Logger类中aroundPrintLog方法开始记录日志了...后置");
    return rtValue;
} catch (Throwable throwable) {
    System.out.println("Logger类中aroundPrintLog方法开始记录日志了...异常");
    throw new RuntimeException();
}finally {
    System.out.println("Logger类中aroundPrintLog方法开始记录日志了...最终");
}

}

AOP注解开发：

<context:component-scan base-package="com.myren"></context:component-scan>

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

例子：
@Component(“logger”)
@Aspect //表示当前类是一个切面类
public class Logger {
/**
* 用于打印日志，计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
*
/
@Pointcut("execution( com.myren.service.impl.AccountServiceImpl.*(…))")
private void pt1(){}

//前置通知，在切入点方法执行之前执行
@Before("pt1()")
public void beforeprintLog(){

    System.out.println("前置通知 Logger类中printlog方法开始记录日志了...");
}
//后置通知，在切入点方法正常执行之后执行，它和异常通知只能执行一个
@AfterReturning("pt1()")
public void afterReturnprintLog(){
    System.out.println("后置通知 Logger类中after Return printLog方法开始记录日志了...");
}
//异常通知，在切入点方法执行产生异常之后执行
@AfterThrowing("pt1()")
public void afterThrowingPrintLog(){

    System.out.println("异常通知 Logger类中after Throwing PrintLog方法开始记录日志了...");
}
//最终通知，无论切入点方法是否正常执行他都会在其后面执行
@After("pt1()")
public void afterPrintLog(){
    System.out.println("最终通知 Logger类中after  PrintLog方法开始记录日志了...");
}
//@Around("pt1()")
public Object aroundPrintLog(ProceedingJoinPoint pjp){
    Object rtValue=null;

    try {
        Object []args=pjp.getArgs();//得到方法执行所需的参数
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了...前置");
        rtValue=pjp.proceed(args);//明确调用业务层方法（切入点方法）
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了...后置");
        return rtValue;
    } catch (Throwable throwable) {
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了...异常");
        throw new RuntimeException();
    }finally {
        System.out.println("Logger类中aroundPrintLog方法开始记录日志了...最终");
    }
}

}

---

基于xml的声明式事务控制

1.配置事务管理器
2.配置事务通知
此时需要导入事务的约束 tx名称空间和约束，同时也需要aop的
使用txadvice标签配置事务通知
属性：
id：给事务通知起一个唯一标识
transaction-manager：给事务通知提供一个事务管理器
3.配置AOP中的通用切入点表达式
4.建立事务通知和切入点表达式的对应关系
5.配置事务的属性
是在事务通知tx：advice标签内部
属性：
isolation：用于指定事务的隔离级别，默认值是DEFAULT,表示的是用数据库的默认隔离级别
propagation：用于指定事务的传播行为，默认值是REQUIRED，表示一定会有事务，增删改的选择，查询方法可以选择SUPPORT
read-only：用于指定事务是否制度，只有查询方法才能设置为true，默认值为false，表示读写
timeout：用于指定事务的超时时间，默认值是-1，表示永不超时，如果指定了数值，以秒为单位
rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚，没有默认值，表示任何异常都回滚
no-rollback-for=用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚，没有默认值，表示任何异常都回滚

aop:config

<aop:pointcut id="pt1" expression="execution(* com.myren.service.impl.*.*(..))"/>
<!--建立切入点表达式和事务通知的对应关系-->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>

</aop:config>

---