spring基础知识总结

1.依赖注入方式：
属性注入
构造函数（类型，索引，联合）
工厂方法（非静态，静态）
泛型


2.参数注入
基本类型
注入bean
内部bean
null
级联属性（原始类中初始化new）
集合（list,set,map,property）


3.自动装配（在配置文件中default-autowire）
byName：通过名称
byType：通过类型
constructor：和类型类似，根据构造方法
建议：少用自动装配，设计不当潜在错误。


4.设置bean作用域 scope设置


5.方法注入（获取每次的依赖对象都是新的）
lookup-method,在添加属性的时候使用这个标签


6.方法替换
replace-method,替换原有对象中的方法，要去替换的对象应该实现MethodReplacer


7.bean之间的关系
继承：在父bean配置时设置abstract=true,子配置bean中class用parent替换实现
依赖：在bean中配置depends-on属性依赖的bean
引用：bean中属性或者构造属性中ref实现


8.作用域
singleton,prototype,request,session,global session,application




9.aop
前置通知
后置通知
环绕通知
返回通知
异常通知


<bean id="studentServiceAspect" class="com.java1234.advice.StudentServiceAspect"></bean>
<bean id="studentService" class="com.java1234.service.impl.StudentServiceImpl"></bean>
<aop:config>
<aop:aspect id="studentServiceAspect" ref="studentServiceAspect">
<aop:pointcut expression="execution(* com.java1234.service.*.*(..))" id="businessService"/>
<aop:before method="doBefore" pointcut-ref="businessService"/>
<aop:after method="doAfter" pointcut-ref="businessService"/>
<aop:around method="doAround" pointcut-ref="businessService"/>
<aop:after-returning method="doAfterReturning" pointcut-ref="businessService"/>
<aop:after-throwing method="doAfterThrowing" pointcut-ref="businessService" throwing="ex"/>
</aop:aspect> 
</aop:config>




package com.java1234.advice;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;


public class StudentServiceAspect {


public void doBefore(JoinPoint jp){
System.out.println("类名:"+jp.getTarget().getClass().getName());
System.out.println("方法名："+jp.getSignature().getName());
System.out.println("开始添加学生："+jp.getArgs()[0]);
}

public void doAfter(JoinPoint jp){
System.out.println("类名:"+jp.getTarget().getClass().getName());
System.out.println("方法名："+jp.getSignature().getName());
System.out.println("学生添加完成："+jp.getArgs()[0]);
}

public Object doAround(ProceedingJoinPoint pjp) throws Throwable{
System.out.println("添加学生前");
Object retVal=pjp.proceed();
System.out.println(retVal);
System.out.println("添加学生后");
return retVal;
}

public void doAfterReturning(JoinPoint jp){
System.out.println("返回通知");
}

public void doAfterThrowing(JoinPoint jp,Throwable ex){
System.out.println("异常通知");
System.out.println("异常信息："+ex.getMessage());
}
}




public interface StudentService {


public void addStudent(String name);
}


public class StudentServiceImpl implements StudentService{


@Override
public void addStudent(String name) {
// System.out.println("开始添加学生"+name);
System.out.println("添加学生"+name);
System.out.println(1/0);
// System.out.println("完成学生"+name+"的添加");
}


}




10.spring对JDBC的支持
配置数据源dbcp
使用jdbcTemplate
使用jdbcDaoSupport，通过集成方式消除jdbcTemplate
使用NamedParameterJdbcTemplate支持命名参数变量




11.事务
编程式事务管理
spring提供的树屋模板类：TransactionTemplate
事务管理器：DataSourceTransactionManger


声明式事务管理
使用xml配置声明
使用注解配置声明


事务传播行为


标准配置模板
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    
    <!-- jdbc事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>  
            <tx:method name="insert*" propagation="REQUIRED" />  
            <tx:method name="update*" propagation="REQUIRED" />  
            <tx:method name="edit*" propagation="REQUIRED" />  
            <tx:method name="save*" propagation="REQUIRED" />  
            <tx:method name="add*" propagation="REQUIRED" />  
            <tx:method name="new*" propagation="REQUIRED" />  
            <tx:method name="set*" propagation="REQUIRED" />  
            <tx:method name="remove*" propagation="REQUIRED" />  
            <tx:method name="delete*" propagation="REQUIRED" />  
            <tx:method name="change*" propagation="REQUIRED" />  
            <tx:method name="get*" propagation="REQUIRED" read-only="true" />  
            <tx:method name="find*" propagation="REQUIRED" read-only="true" />  
            <tx:method name="load*" propagation="REQUIRED" read-only="true" />  
            <tx:method name="*" propagation="REQUIRED" read-only="true" />  
        </tx:attributes>  
    </tx:advice>
    
    <!-- 配置事务切面 -->
    <aop:config>
    <!-- 配置切点 -->
    <aop:pointcut id="serviceMethod" expression="execution(* com.java1234.service.*.*(..))" />
    <!-- 配置事务通知 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/>
    </aop:config> 


<context:property-placeholder location="jdbc.properties"/>
    
    <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
    <constructor-arg ref="dataSource"></constructor-arg>
    </bean>

<bean id="bankDao" class="com.java1234.dao.impl.BankDaoImpl">
<property name="namedParameterJdbcTemplate" ref="namedParameterJdbcTemplate"></property>
</bean>
<bean id="bankService" class="com.java1234.service.impl.BankServiceImpl">
<property name="bankDao" ref="bankDao"></property>
</bean> 









1.spel（动态生成）
#{}可以是别的bean，可以是别的bean属性，可以是方法（动态为属性赋值），可以是正则(matches)，可以有运算符（+-*/^ ）比较运算符（>,<,>=,<=,==）逻辑运算符（and,or,not,|,？：），可以 T(). 方式静态方法属性调用。




2.spring容器对bean中声明了init-method和destroy-method的方法在初始化和销毁时进行调用，可以在配置文件中配置或者注解。在注解开发使用
@PostConstruct和@PreDestroy


除了定义上述2个方法外，spring还提供了一个接口可以实现bean在init的前后添加自己的逻辑BeanPostProcessor
public class BeanPostPrcessorImpl implements BeanPostProcessor { 
    // Bean 实例化之前进行的处理
    public Object postProcessBeforeInitialization(Object bean, String beanName)
           throws BeansException {
       System.out.println("对象" + beanName + "开始实例化");
       return bean;
    }
 
    // Bean 实例化之后进行的处理
    public Object postProcessAfterInitialization(Object bean, String beanName)
           throws BeansException {
       System.out.println("对象" + beanName + "实例化完成");
       return bean;
    }
} 
这2个接口方法返回bean用户可以自定义实现偷梁换柱
只要将这个BeanPostProcessor接口的实现定义到容器中就可以了，容器在加载它的时候回特殊处理（applicationcontext可以，而beanfactory则需要另外的方式），如下所示：
<bean class="com.spring.test.di.BeanPostPrcessorImpl"/>


3.除了xml配置bean，注解，java类，groovy配置




4.xml中配置bean除了直接配置类还可以使用静态工厂和实例工厂创建bean（用的少），spring还提供了一个接口FactoryBean，这样配置到
xml文件后容器发现这个bean实现了FactoryBean会自动调用生成bean的方法。


5.跨域引用使用<aop:scoped-proxy/>。需要引入CGLib的jar包。


6.在使用注解方式加载bean用<context:component-scan base-package="包1，包2">可以使用context:include-filter现在只需要哪些包和context:exclude-filter排除哪些包。


7.泛型依赖注入：只需要在父类中建立好依赖注入的泛型，子类会根据在显示的时候创建的T对应的替换类型自动建立子类之间的依赖关系。


8.aop术语：切面，通知，目标，代理。
连接点：程序执行到程序的某个位置，相当于方法执行前后者执行后
切点：相当于一个连接点的查询条件，一个切点对应多个连接点。
可以使用@order（权值）指定优先级
重用切点表达式：写一个空方法写上切入表达式，其他方法都是用这个方法作为切入点


9.jdbcTemplate和NamedParameterJdbcTemplate简化常规JDBC操作，模板方法操作。NamedParameterJdbcTemplate可以根据根据实体属性与数据库字段进行名称相同的映射，这样在插入和获取时取出数据时已经做了相应的转化。


10.事务（传播性，隔离性，异常是否回滚，只读，超时）
jdbc有DataSourceTransactionManger(mybatis也使用这个)
javaEE代码事务有JtaTransactionManger
hibernate有HibernateTransactionManger


以前普通java实现jdbc事务使用的是try...catch方式在不同的地方提交事务、回滚事务关闭连接等，针对切面来说也就是可以针对
不同的方法在不同的地方实现一个切面编程的模型，使用spring的AOP技术可以实现这种模式变得简单。


编程式事务和声明式事务
注解式声明式事务：xml配置数据源和事务以及<tx:annotation-driven transcation-manger="事务引用"/>，在需要事务的方法上加上transactional


编程式事务提供了事务模板（比较麻烦）


异常继承runtimeException


事务传播性：
require 底层方法将使用上层方法的事务（默认的传播行为） @Transactional(propagation=Propagation.REQUIRES)
require_new 底层方法使用自己的事务，成功自己可以提交   @Transactional(propagation=Propagation.REQUIRES_NEW)


Propagation ：　　key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。




事务的隔离级别：
isolation指定，常用READ_COMMITTED
ISOLATION_DEFAULT： 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
      另外四个与JDBC的隔离级别相对应
ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。
      这种隔离级别会产生脏读，不可重复读和幻像读。
ISOLATION_READ_COMMITTED： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据
ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。
      它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。
      除了防止脏读，不可重复读外，还避免了幻像读。


异常是否回滚（默认有异常就回滚）


readonly 指定事务为只读事务，帮助数据库优化


timeout 指定强制回滚之前事务可以占用的时间，如果时间超过则事务自动回滚。