Spring4 笔记

1. 通过 xml 赋值给 bean　　

1） 通过set 方法赋值　（必须要有空的构造方法）

2） 通过构造方法赋值

　 3）装配 list 属性　（实体类中必须先定义好list）

4）装配 map 属性　　（实体类中必须先定义好 map）

　　5）装配 properties 属性

　　<bean id="jdbcDatabase" class="com.test.JDBCDatabase">
　　　　<property name="properties">
　　　　　　<props>
　　　　　　　　<prop key="user">root</prop>
　　　　　　　　<prop key="password">123</prop>
　　　　　　　　<prop key="jdbcUrl">com.mysql.jdbc.Driver</prop>
　　　　　　　　<prop key="driverClasss">jdbc:mysql://test</prop>
　　　　　　</props>
　　　　</property>
　　</bean>

　　6）声明集合类型的 bean，也可以是map

　　　　<util:list id="books2">
　　　　　　<ref bean="book"/>
　　　　　　<ref bean="book2"/>
　　　　</util:list>

　　7）简易写法 ref 6）中的 books2

　　8）自动装配　　byName 是通过 persion中的set方法来匹配装配项，如下的： address 和 car （在开发中很少会使用）

　　　　　　　　　　byType 是通过类型进行装配（如上的Address类和Car类，如果有2个同样的类，就不能装配了）

　　9）配置继承　　将相同的去掉，使用 parent="address2" 来实现继承没有的属性

　　10）抽象 bean ，只能用来被继承，不能被实例化、　　如果是非抽象bean ，则必须要有属性值

　　11） bean 依赖关系，如果配置了 depends-on="car" 属性，则必须要有一个定义了 car 的bean，

　　12） bean 的作用域如果配置了 scope="singleton" 属性，表示在整个bean的生命周期中是单例的，只创建这一个bean （默认值为这个）

　　　　　　　　　　　　　　　如果配置了 scope="prototype" 属性，表示在整个bean的生命周期中是原型的，每次会创建一个新的bean

　　13) 通过bean 链接mysql　　　　

　　　　ApplicationContext ctx = new ClassPathXmlApplicationContext("jdbcBeans.xml");
　　　　javax.sql.DataSource dataSource = (javax.sql.DataSource)ctx.getBean("dataSource");
　　　　System.out.println(dataSource.getConnection());

　　14）通过引用外部文件来获取链接数据库信息， spring 链接数据库

　　　　　　1> 新建 db.properties 文件，内容为：　　　　　　

　　　　　　　　　user=root
　　　　　　　　password=root
　　　　　　　　driverClass=com.mysql.jdbc.Driver
　　　　　　　　jdbcUrl=jdbc:mysql:///mysql

　　　　　 2> bean配置文件内容为：　　　　

　　　　　　　　<context:property-placeholder location="classpath:db.properties"/>
　　　　　　3> 配置 bean配置文件内容类似于 el 表达式的方式来获取
　　　　　　　　<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
　　　　　　　　　　<property name="user" value="${user}"></property>
　　　　　　　　　　<property name="password" value="${password}"></property>
　　　　　　　　　　<property name="driverClass" value="${driverClass}"></property>
　　　　　　　　　　<property name="jdbcUrl" value="${jdbcUrl}"></property>
　　　　　　　　</bean>

　　15）引用外部函数来动态指定属性值　（SpEl表达式）　　　

　　16）通过SpEl 表达式来引用其他bean

　　　　通过SpEl 表达式来引用其他bean中的属性（动态赋值）

　　17） bean 的生命周期， init2 和 destroy 都是 Car中自定义的方法，在启动这个IOC容器会先调用 init2 方法，关闭的时候会调用 destroy 方法

　　　　执行顺序是：构造方法----> init ----> main ----> destroy

　　18） bean 的后置处理器（检查 bean 的合法性）, 这样在这个配置文件下所有的bean都会执行这个后置处理器，这个配置和在Car类中不需要增加任何东西

　　　　1> bean 的配置如下：

　　　　2> 后置处理器类的内容如下：需要实现 BeanPostProcessor 接口

　　　　public class MYBeanPostProcessor implements BeanPostProcessor {

　　　　　　public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
　　　　　　System.out.println("postProcessBeforeInitialization "+ bean + " "+ beanName);
　　　　　　return bean;
　　　　}

　　　　public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
　　　　　　System.out.println("postProcessAfterInitialization "+ bean + " "+ beanName);
　　　　　　return bean;
　　　　}

　　　　执行流程将会变为：构造方法 ----> postProcessBeforeInitialization ----> init ----> postProcessAfterInitialization ---- main　　　　　　----> destroy

　 19）静态工厂方法来配置 bean，不需要实例化工厂类，注意不是配置静态工厂方法实例，而是配置bean实例

　　　　1> bean配置内容如下：class指定静态方法工厂类， factory-method指定指定获取指定bean的具体方法，

　　　　　　如果工厂方法需要传入参数，则使用 constructor-arg 传入参数　　　

　　　　2> 静态方法类内容如下：　　　　　　

　　　　　　public class StaticFactory {
　　　　　　　　private static Map<String, Car> cars = new HashMap<String, Car>();

　　　　　　　　static {
　　　　　　　　　　cars.put("aodi", new Car("aodi",300000));
　　　　　　　　　　cars.put("baoma", new Car("baoma", 500000));
　　　　　　　　}

　　　　　　　　public static Car getCar(String name) {
　　　　　　　　　　return cars.get(name);
　　　　　　　　}
　　　　　　}

　　 20）实例工厂方法：需要先实例化工厂，再实例化 bean

　　　　1> bean 代码如下：　　　　　　

　　　　2> 实例工厂代码如下：　　　　　　

　　　　　　public class InstenceFactory {
　　　　　　　　private Map<String, Car> cars = null;
　　　　　　　　public InstenceFactory() {
　　　　　　　　　　cars = new HashMap<String, Car>();
　　　　　　　　　　cars.put("aodi", new Car("aodi", 300000));
　　　　　　　　　　cars.put("ford", new Car("ford", 500000));
　　　　　　　　}
　　　　　　　　public Car getCar(String name) {
　　　　　　　　　　return cars.get(name);
　　　　　　　　}
　　　　　　}

　　21）通过 spring 自带的 FactoryBean 来配置bean

　　　　1> bean 配置如下：　　　　　　

　　　　2> 自定义类 CarFactoryBean 代码如下：　　　　　　

　　　　　　public class CarFactoryBean implements FactoryBean<Car>{
　　　　　　　　private String name;
　　　　　　　　public void setName(String name) {
　　　　　　　　　　this.name = name;
　　　　　　　　}
　　　　　　　　public Car getObject() throws Exception {

　　　　　　　　　　return new Car(name, 500000);
　　　　　　　　}
　　　　　　　　public Class<?> getObjectType() {
　　　　　　　　　　return Car.class;
　　　　　　　　}
　　　　　　　　public boolean isSingleton() {
　　　　　　　　　　return true;
　　　　　　　　}
　　　　　　}

　　22）通过注解来配置 bean

　　　　1> 扫描annotation包下的所有类和子包下的所有类

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

　　　　2> 只扫描 annotation包下的 component包下的所有类

　　　　　　<context:component-scan base-package="com.annotation" resource-pattern="component/*.class"></context:component-scan>

　　　　3> 不包含 @Repository 来注解的类　　　　　　

　　　　　　<context:component-scan base-package="com.annotation" >
　　　　　　　　<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
　　　　　　</context:component-scan>

　　　　4> 只包含 @Repository 来注解的类　（使用 annotation 来对注解类的过滤）　　　　　　　

　　　　　　<context:component-scan base-package="com.annotation" use-default-filters="false">
　　　　　　　　<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
　　　　　　</context:component-scan>

　　　　5> 不包含具体的类或接口　　　　　　

　　　　　　<context:component-scan base-package="com.annotation">
　　　　　　　　<context:exclude-filter type="assignable" expression="com.annotation.service.userService.UserService"/>
　　　　　　</context:component-scan>

　　　　6> 只包含具体的类或接口（使用 assignable 来指定对具体类来过滤）

　　　　　　<context:component-scan base-package="com.annotation" use-default-filters="false">
　　　　　　　　<context:include-filter type="assignable" expression="com.annotation.service.userService.UserService"/>
　　　　　　</context:component-scan>

　　　　7> 对 IOC容器中的类里面的属性进行自动装配（也就是说组件之间的相互引用）

　　　　　　例如：@Autowired，也可以放到 set方法上， @Autowired默认设置的属性都必须在 IOC 容器里管理，否则会抛异常找不到 bean　

　　　　　　　　如果容许可以不是 IOC 容器里的bean 可以这样进行设置：@Autowired(required=false) 　　　　　　　

　　　　　　　　@Controller
　　　　　　　　public class UserController {
　　　　　　　　　　@Autowired
　　　　　　　　　　private UserRespository userRespository;

　　　　　　　　　　public void save() {
　　　　　　　　　　　　System.out.println("UserController...");
　　　　　　　　　　userRespository.save();
　　　　　　　　　　}
　　　　　　　　}

　　　　　8> @Autowired 可以用在数组，集合， map 上

　　23) 使用 spring 中的 AOP 来实现动态代理前置通知（顺便看动态代理实现方式）所需要的包为：

　　　　1> 前置通知类所有通知中可以没有 JoinPoint 参数和其他参数

　　　　　　　　1.xml 配置文件　　　　

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

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

　　　　　　　　2. 前置通知类：其中 @Before("execution(public int com.aopImpl.ArithmeticCalculator.*(int, int))")可以是用通配符来匹配

　　　　　　　　比如 @Before("execution(* com.aopImpl.*.*(int, int))")　这样就表示，第1* 表示任意返回值，com.aopImpl 第2* 表示包下的所

　　　　　　　　　　有类，第3* 表示中的所有方法　　　

　　　　　　　　　　@Aspect
　　　　　　　　　　@Component
　　　　　　　　　　public class loggingAspect {
　　　　　　　　　　　　@Before("execution(public int com.aopImpl.ArithmeticCalculator.*(int, int))") //指定加入的类方法
　　　　　　　　　　　　public void beforeMethod(JoinPoint joinPoint) {
　　　　　　　　　　　　　　String methodName = joinPoint.getSignature().getName();
　　　　　　　　　　　　　　List<Object> args = Arrays.asList(joinPoint.getArgs());
　　　　　　　　　　　　　　System.out.println("The method "+methodName+" begin with "+args );
　　　　　　　　　　　　}
　　　　　　　　　　　}

　　　　　　主要有这几种通知

　　　　　　2> 后置通知（@After）是在方法执行完后或抛出异常时都会执行，但不能访问方法返回结果，返回结果需要在返回通知中访问

　　　　　　3> 返回通知（@AfterReturning）是在方法正确执行完之后才执行的，可以访问到返回值　　　　　　

　　　　　　　　@AfterReturning(value = "execution(* com.aop2.*.*(int, int))", returning="result")
　　　　　　　　public void afterReturnAop(JoinPoint joinPoint, Object result) {
　　　　　　　　　　System.out.println("The afterReturning ..."+joinPoint.getSignature().getName()+" result is "+result);
　　　　　　　　}

　　　　　　4> 异常通知，可以指定具体抛出那个异常才去执行：比如： NullPointerException ex　　　　　

　　　　　　　　@AfterThrowing(value = "execution(* com.aop2.*.*(..))", throwing="ex")
　　　　　　　　public void afterThrowingAop(JoinPoint joinPoint, Exception ex) {
　　　　　　　　　　System.out.println("The afterThrowing Exception is : "+ex.getMessage());
　　　　　　　　}

　　　　　　5> 环绕通知，　　　　　　　　

　　　　　　　　/**
　　　　　　　　* 环绕通知需要携带 ProceedingJoinPoint 类型的参数
　　　　　　　　* 环绕通知类似于动态代理的全过程， ProceedingJoinPoint 类型的参数可以决定是否执行目标方法
　　　　　　　　* 且环绕通知必须有返回值，返回值即为目标方法的返回值
　　　　　　　　* @param pjd
　　　　　　　　*/
　　　　　　　　@Around(value = "execution(* com.aop.*.*(int, int))")
　　　　　　　　public void aroundMethod(ProceedingJoinPoint pjd) {
　　　　　　　　　　String methodName = pjd.getSignature().getName();
　　　　　　　　　　try {
　　　　　　　　　　　　//前置通知
　　　　　　　　　　　　System.out.println("The method "+methodName+" 前置通知 with "+ Arrays.asList(pjd.getArgs()) );
　　　　　　　　　　　　//执行目标方法
　　　　　　　　　　　　Object result = pjd.proceed();
　　　　　　　　　　　　//返回通知
　　　　　　　　　　　　System.out.println("The method "+methodName+" 返回通知 with "+ Arrays.asList(pjd.getArgs()) );

　　　　　　　　　　} catch (Throwable e) {
　　　　　　　　　　　　//异常通知
　　　　　　　　　　　　System.out.println("The method "+methodName+" 异常通知 with "+ e);
　　　　　　　　　　　　throw new RuntimeException();
　　　　　　　　　　}
　　　　　　　　　　//后置通知
　　　　　　　　　　System.out.println("The method "+methodName+" 后置通知 with "+ Arrays.asList(pjd.getArgs()) );
　　　　　　　　}

　　　　　　6> 如果有多个切面类，可以使用 @Order(1) 来指定切面优先级，值越小，优先级越高，如：

　　　　　　　　@Order(1)
　　　　　　　　@Around(value = "execution(* com.aop.*.*(int, int))")
　　　　　　　　public void aroundMethod(ProceedingJoinPoint pjd) {

　　　　　7> 定义切入点表达式，以便重用　(该方法不需要填入其他代码)　　　

　　　　　　　　@Pointcut("execution(* com.aop.*.*(int, int))")
　　　　　　　　public void jointPointExpression() {}

　　　　　　　　使用如下： <1> 同类中 @Before("jointPointExpression()")

　　　　　　　　　　　　　 <2> 同包不同类中 @Before("类名.jointPointExpression()") (类名指定义切入点方法的类)

　　　　　　　　　　　　　 <3> 不同包 @Before("包.类名.jointPointExpression()")

　　　　　　8> 通过xml 来配置通知