Spring

一、Spring的介绍

1.什么是spring？

spring是轻量级的javaEE应用开源框架

2.spring的好处？

IOC
AOP
粘合剂

二、IOC

1.耦合

偶和： 对象之间的依赖关系（service依赖dao），耦合度越高维护成本越高

2.IOC

IOC(Inverse of Control)控制反转： 正传是自己new对象，反转是由工厂创建对象

3、工厂模式的IOC解耦合

	1、把service和dao配置到beans.properties
    2、读取beans.properties
    3、通过反射创建对象，并装到容器中
    4、使用时，直接从容器中获取
             |
             |
        工厂：①通过反射创建对象  ②把对象装容器

4、spring的IOC解耦合

    0、拷贝BeanFactory--->Spring_IOC_Xml
    1、pom.xml
        spring-context
    2、applicationContext.xml
        <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
        <bean id="userService" class="com.by.service.UserServiceImpl"></bean>
    3、测试
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = ac.getBean("userService", UserService.class);
        userService.addUser();

5、DI

1、DI是什么？

DI(Dependency Injection)依赖注入：把依赖对象(userDao)从容器中(map)拿出来赋值给调用者(userService)

2、DI方式

①构造方法注入

            a、提供构造方法
                public UserServiceImpl(UserDao userDao) {
                        this.userDao = userDao;
                }
            b、注入
                <constructor-arg name="userDao" ref="userDao"></constructor-arg>

②set方法注入

            a、提供set方法
                public void setUserDao(UserDao userDao) {
                        this.userDao = userDao;
                }
            b、注入
                <property name="userDao" ref="userDao"></property>

③自动注入

            a、提供set方法
                public void setUserDao(UserDao userDao) {
                        this.userDao = userDao;
                }
            b、注入
                <bean id="" class="" autowire="byType">

6、BeanFactory和ApplicationContext区别

ApplicationContext：子接口，上来就创建对象
BeanFactory：顶级接口，getBean()时才创建对象

7、spring bean的作用域范围(bean放哪了)

singleton：单例，IOC容器
prototype：多例，每次都创建
request：request域
session：session域
application：servletContext域

单例和多例的使用场景？
单例：servie、dao、SqlSessionFactory
多例：connection、SqlSession

8、spring bean的生命周期

单例：[创建容器]—>构造方法(实例化)---->set方法(注入)—>init方法(初始化)—>[容器关闭]—>destroy方法(销毁bean)
多例：[getBean]—>构造方法(实例化)---->set方法(注入)—>init方法(初始化)—>[JVM垃圾回收]---->destroy方法(销毁bean)

三、spring基于注解的IOC

1、常用注解

1）IOC注解

        @Controller：web
        @Service：service
        @Repository：dao
        @Component：三层架构之外
        @Scope：指定bean的作用域范围，eg：singleton、prototype、request、session、application

2）DI注解

        @Resource(name="")：按名称注入，即按map的key值获取对象
        @Autowired：按类型注入
        @Value：注入基本类型

2、配置步骤

1）applicationContext.xml

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

2）ioc

        @Repository
        public class UserDaoImpl implements UserDao{

        }
        @Service
        public class UserServiceImpl implements UserService{

        }

3）di

        public class UserServiceImpl implements UserService{
            @Autowired
            private UserDao userDao;
        }

四、spring的AOP

1、为什么要使用AOP?

    有一万个service类，要求每个方法执行前打印日志，执行后打印日志

2、什么是AOP?

AOP(Aspect Oriented Programming)面向切面编程：把程序中重复的代码抽取出来，使用动态代理的技术取执行

3、代理模式

1）静态代理

        角色：
            公共接口：Star
            真实角色：RealStar(周杰伦.唱歌()...)
            代理角色：ProxyStar(宋吉吉.面谈().签合同().订机票().[周杰伦.唱歌()].收尾款())
            客户：Client(小孩.接口)
        缺点：1.大量重复代码 2.只能代理Star类型的对象

2）jdk动态代理

        角色：
            公共接口：Star
            真实角色：RealStar(周杰伦.唱歌())
            代理工厂：ProxyFactory(生成ProxyStar)
            客户：Client(小孩.接口)

3）cglib动态代理

        cglib和jdk动态代理的区别：cglib的真实角色没有接口

4、aop的核心概念

    切点(pointcut)：要增强的方法，eg：add()、update()
    增强/通知(advice)：要搞的事情，eg：日志、控制事务
        前置通知：aop:before
        后置通知：aop:after-returning 【try】
        最终通知：aop:after 【finally】
        异常通知：aop:after-throwing 【catch】
        环绕通知：aop:around

        aop:before
        try{
            ...
            return aop:after-returning
        }catch(){
            ...
            aop:after-throwing
        }finally{
            aop:after
        }
    切面(aspect)：把增强应用到切点上

5、切点表达式

    格式：
        execution([修饰符] 返回值类型 包名.类名.方法名(参数))
    eg：
        execution(* com.by.service.*.*(..))