权限管理demo-获取Spring上下文工具

1. spring是一个轻量级的开源框架，简化了java应用的开发。它的核心是Ioc和Aop.

　好处：方便解耦，简化开发。AOP编程的支持。声明式事务的支持。测试方便。方便集成各种常用框架。

2. Ioc, 控制反转。将对象创建权由开发者反转给spring容器，并通过容器管理对象的生命周期。

　AOP, 面向切面编程。针对目标对象进行动态代理，实现功能增强。减少重复代码，降低主业务与此业务的耦合度。比如记录日志，权限控制

3. IoC容器（也称spring容器)本质上就是创建并管理类的实例的工厂，在spring框架中，主要有两个工厂接口：BeanFactory和ApplicationContext.ApplicationContext继承了BeanFactory,在spring容器初始化的时候便会创建bean, 而BeanFactory是延迟加载，用到的时候才会初始化bean.

4. Spring IoC容器配置bean信息的方式有xml配置方式和注解方式

　　***xml配置方式：bean标签

　　***注解方式：@Component @Controller @Service @Repository, 需要使用context:component-scan标签配合使用

5. Spring IoC容器的创建主要有两种场景：

　　*** 非web环境：主要通过ApplicationContext接口的两个实现类来完成：ClasspathXmlApplicationContext和　　FileSystemXmlApplicationContext

　　***web环境：主要通过ContextLoaderListener(实现ServletContextListener接口）创建webApplicationContext后，放入ServerletContext中。

6. DI : bean工厂在生成bean对象的时候，动态地将依赖的对象注入到bean组件中

　　***依赖注入的方式：构造方法注入 、set方法注入（手动装配方式、自动装配方式）

　　***手动装配方式（xml) ： bean标签的子标签property, 需要在类中指定set方法。

　　***自动装配方式（注解）：@Autowired @Resource

 

7. Spring AOP实现原理：动态代理技术（JDK的动态代理和CGLIB动态代理，根据是否实现接口来选择使用哪种代理方式）

8. web服务器（servlet容器）： tomcat\jetty等

9. web容器：ServletContext

10. web容器初始化过程

（1）web服务器（tomcat）启动会加载web.xml（启动ContextLoaderListener监听器）

（2）web服务器启动后，会创建ServletContext（web上下文，也就是web容器），此时会触发ContextLoaderListener监听器的contextInitialized()方法。

（3）contextInitialized()方法中会调用initWebApplicationContext()方法，该方法负责创建Spring容器和生产Bean对象。

initWebApplicationContext()方法负责创建WebApplicationContext（实际创建的是此接口的默认实现类XmlWebApplicationContext, web环境中的真正容器）

（4）加载spring配置文件，并创建beans。通过configureAndRefreshWebApplicationContext()方法

（5）将spring容器context挂载到ServletContext 这个web容器上下文中。通过servletContext.setAttribute()方法。

11. web三类八种监听器：

***监听域对象的生命周期：

*ServletContextListener：

*创建：服务器启动

*销毁：服务器正常关闭

*spring ContextLoaderListener(服务器启动时负责加载Spring配置文件)

*HttpSessionListener

*创建：第一次访问request.getHttpSession();

*销毁：调用invalidate();非法关闭；过期

*ServletRequestListener

*创建：每一次访问

*销毁：响应结束

***监听域对象的属性：（添加、删除、替换）

* ServletContextAttributeListener

* HttpSessionAttributeListener

* ServletRequestAttributeListener

***监听HttpSession中JavaBean的改变：

* HttpSessionBindingListener（HttpSession和JavaBean对象的绑定和解绑）

* HttpSessionActivationListener（HttpSession的序列化，活化、钝化）

12. spring容器初始化过程：

１、ResourceLoader从存储介质中加载Spring配置信息，并使用Resource表示这个配置文件的资源；

２、BeanDefinitionReader读取Resource所指向的配置文件资源，然后解析配置文件。配置文件中每一个<bean>解析成一个BeanDefinition对象，并保存到BeanDefinitionRegistry中；

３、容器扫描BeanDefinitionRegistry中的BeanDefinition，使用Java的反射机制自动识别出Bean工厂后处理后器（实现BeanFactoryPostProcessor接口）的Bean，然后调用这些Bean工厂后处理器对BeanDefinitionRegistry中的BeanDefinition进行加工处理。主要完成以下两项工作：

1）对使用到占位符的<bean>元素标签进行解析，得到最终的配置值，这意味对一些半成品式的BeanDefinition对象进行加工处理并得到成品的BeanDefinition对象；

2）对BeanDefinitionRegistry中的BeanDefinition进行扫描，通过Java反射机制找出所有属性编辑器的Bean（实现java.beans.PropertyEditor接口的Bean），并自动将它们注册到Spring容器的属性编辑器注册表中（PropertyEditorRegistry）；

4．Spring容器从BeanDefinitionRegistry中取出加工后的BeanDefinition，并调用InstantiationStrategy着手进行Bean实例化的工作；

5．在实例化Bean时，Spring容器使用BeanWrapper对Bean进行封装，BeanWrapper提供了很多以Java反射机制操作Bean的方法，它将结合该Bean的BeanDefinition以及容器中属性编辑器，完成Bean属性的设置工作；

6．利用容器中注册的Bean后处理器（实现BeanPostProcessor接口的Bean）对已经完成属性设置工作的Bean进行后续加工，直接装配出一个准备就绪的Bean。

13. <context:property-placeholder location="classpath:db.properties" />使用PropertyPlaceholderConfigurer类实现。

14. IoC容器创建Bean对象源码分析：（AbstractApplicationContext)

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

              //1.创建真正的Spring容器（DefaultListableBeanFactory）
              //2.加载BeanDefition（描述要初始化的Bean的信息）
              //3.将BeanDefition注册到BeanDefitionRegistry
            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                  //执行实现了BeanFactoryPostProcessor接口的Bean
                  //比如PropertyPlaceHolderConfigurer（context:property-placeholer）就是此处被调用的，替换掉BeanDefition中的占位符（${}）中的内容
                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                  //注册BeanPostProcessor（后置处理器）
                  //比如容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器（实现@Autowired注解功能）
                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                  //初始化非懒加载方式的单例Bean实例
                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.

15. bean标签

***bean标签作用：

***用于配置对象让 spring 来创建的。

***默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

***bean标签属性：

***id：给对象在容器中提供一个唯一标识。用于获取对象。

***class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。

***scope：指定对象的作用范围。

* singleton :默认值，单例的（在整个容器中只有一个对象）.

* prototype :多例的.

* request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.

* session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.

* global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.

***init-method：指定类中的初始化方法名称。

***destroy-method：指定类中销毁方法名称。比如DataSource的配置中一般需要指定destroy-method=“close”。

***bean的作用范围：

***单例对象：scope="singleton"

***一个应用只有一个对象的实例。它的作用范围就是整个引用。

***生命周期：

*对象出生：当应用加载，创建容器时，对象就被创建了。

*对象活着：只要容器在，对象一直活着。

*对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

***多例对象：scope="prototype"

***每次访问对象时，都会重新创建对象实例。

***生命周期：

*对象出生：当使用对象时，创建新的对象实例。

*对象活着：只要对象在使用中，就一直活着。

*对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

16. 实例化bean的三种方式

（1）默认使用无参构造函数

（2）静态工厂

（3）实例工厂

17. spring中注解：

@Autowired相当于<property name="" ref="">

***默认按类型装配（byType）

***这个注解是spring自身的

***默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false，如：@Autowired(required=false)

***如果我们想使用名称装配可以结合@Qualifier注解进行使用

@Qualifier

***在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。

***它在给字段注入时不能独立使用，必须和@Autowire 一起使用；但是给方法参数注入时，可以独立使用。

@Resource

***默认按照名称（byName）进行装配，名称可以通过name属性进行指定

***这个注解属于J2EE的

***如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，当找不到与名称匹配的bean时才按照类型进行装配。

***但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

@Value

***给基本类型和String类型注入值

***可以使用占位符获取属性文件中的值。

@Value(“${name}”)//name是properties文件中的key

private String name;

@Configuration

***从Spring3.0，@Configuration用于定义配置类，可替换xml配置文件

***相当于<beans>根标签

***配置类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

• 属性：

value:用于指定配置类的字节码

• 示例代码：

@Configuration

public class SpringConfiguration {

//spring容器初始化时，会调用配置类的无参构造函数

public SpringConfiguration(){

System.out.println(“容器启动初始化。。。”);

}

}

@Bean

***@Bean标注在方法上(返回某个实例的方法)，等价于spring配置文件中的<bean>

***作用为：注册bean对象

***主要用来配置非自定义的bean，比如DruidDataSource、SqlSessionFactory

***name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。

***如果不指定，默认与标注的方法名相同

***@Bean注解默认作用域为单例singleton作用域，可通过@Scope(“prototype”)设置为原型作用域；

• 示例代码：

@Configuration

public class SpringConfiguration {

//spring容器初始化时，会调用配置类的无参构造函数

public SpringConfiguration(){

System.out.println(“容器启动初始化。。。”);

}

@Bean

@Scope(“prototype”)

public UserService userService(){

return new UserServiceImpl(1,“张三”);

}

}

@ComponentScan

***相当于context:component-scan标签

***组件扫描器，扫描@Component、@Controller、@Service、@Repository注解的类。

***该注解是编写在类上面的，一般配合@Configuration注解一起使用。

***basePackages：用于指定要扫描的包。

***value：和basePackages作用一样。

@PropertySource

***加载properties配置文件

***编写在类上面

***相当于context:property-placeholder标签

• 属性

value[]：用于指定properties文件路径，如果在类路径下，需要写上classpath

• 示例代码

@Configuration

@PropertySource(“classpath:jdbc.properties”)

public class JdbcConfig {

@Value("${jdbc.driver}")

private String driver;

@Value("${jdbc.url}")

private String url;

@Import

***用来组合多个配置类

***相当于spring配置文件中的import标签

***在引入其他配置类时，可以不用再写@Configuration 注解。当然，写上也没问

@Configuration

@ComponentScan(basePackages = "com.kkb.spring")

@Import({ JdbcConfig.class})

public class SpringConfiguration {

}

@Configuration

@PropertySource("classpath:jdbc.properties")

public class JdbcConfig{

}

18. AOP编程术语：

切面：切入点和通知的结合。

织入：将切面织入到目标对象的目标方法的过程

连接点（Joinpoint)：目标对象中可以被切面织入的方法

切入点(pointcut)：目标对象中真正被切面切入的方法

通知：拦截到连接点后要做的事情

顾问（Advisor): 切面的一种，能将通知以更为复杂的方式织入到目标对象。

19. 通知类型

***通知类型（五种）：前置通知、后置通知、最终通知、环绕通知、异常抛出通知。

***前置通知：

***执行时机：目标对象方法之前执行通知

***配置文件：<aop:before method="before" pointcut-

ref="myPointcut"/>

***应用场景：方法开始时可以进行校验

***后置通知：

***执行时机：目标对象方法之后执行通知，有异常则不执行了

***配置文件：<aop:after-returning method="afterReturning" pointcut-ref="myPointcut"/>

***应用场景：可以修改方法的返回值

***最终通知：

***执行时机：目标对象方法之后执行通知，有没有异常都会执行

***配置文件：<aop:after method="after" pointcut-ref="myPointcut"/>

***应用场景：例如像释放资源

***环绕通知：

***执行时机：目标对象方法之前和之后都会执行。

***配置文件：<aop:around method="around" pointcut-ref="myPointcut"/>

***应用场景：事务、统计代码执行时机

***异常抛出通知：

***执行时机：在抛出异常后通知

***配置文件：<aop:after-throwing method=" afterThrowing " pointcut- ref="myPointcut"/>

***应用场景：包装异常

20.

1. 事务：指的是逻辑上一组操作，组成这个事务的各个执行单元，要么一起成功,要么一起失败！

2. 事务的特性

* 原子性

* 一致性

* 隔离性

* 持久性

3. 如果不考虑隔离性,引发安全性问题

* 读问题:

* 脏读:

* 不可重复读:

* 虚读:

4. 如何解决安全性问题

* 读问题解决，设置数据库隔离级别

21. spring框架的事务管理相关

1. PlatformTransactionManager接口     -- 平台事务管理器.(真正管理事务的类)。该接口有具体的实现类，根据不同的持久层框架，需要选择不同的实现类！

2. TransactionDefinition接口          -- 事务定义信息.(事务的隔离级别,传播行为,超时,只读)

3. TransactionStatus接口              -- 事务的状态

4. 总结：上述对象之间的关系：平台事务管理器真正管理事务对象.根据事务定义的信息TransactionDefinition 进行事务管理，在管理事务中产生一些状态.将状态记录到TransactionStatus中

5. PlatformTransactionManager接口中实现类和常用的方法

1. 接口的实现类

* 如果使用的Spring的JDBC模板或者MyBatis框架，需要选择DataSourceTransactionManager实现类

* 如果使用的是Hibernate的框架，需要选择HibernateTransactionManager实现类

2. 该接口的常用方法

* void commit(TransactionStatus status)

* TransactionStatus getTransaction(TransactionDefinition definition)

* void rollback(TransactionStatus status)

6. TransactionDefinition

1. 事务隔离级别的常量

* static int ISOLATION_DEFAULT              -- 采用数据库的默认隔离级别

* static int ISOLATION_READ_UNCOMMITTED

* static int ISOLATION_READ_COMMITTED

* static int ISOLATION_REPEATABLE_READ

* static int ISOLATION_SERIALIZABLE

2. 事务的传播行为常量（不用设置，使用默认值）

* 先解释什么是事务的传播行为：解决的是业务层之间的方法调用！！

* PROPAGATION_REQUIRED（默认值） -- A中有事务,使用A中的事务.如果没有，B就会

开启一个新的事务,将A包含进来.(保证A,B在同一个事务中)，默认值！！

* PROPAGATION_SUPPORTS          -- A中有事务,使用A中的事务.如果A中没有事务.那么B也不使用事务.

* PROPAGATION_MANDATORY         -- A中有事务,使用A中的事务.如果A没有事务.抛出异常.

* PROPAGATION_REQUIRES_NEW      -- A中有事务,将A中的事务挂起.B创建一个新的事务.(保证A,B没有在一个事务中)

* PROPAGATION_NOT_SUPPORTED     -- A中有事务,将A中的事务挂起.

* PROPAGATION_NEVER             -- A中有事务,抛出异常.

* PROPAGATION_NESTED            -- 嵌套事务.当A执行之后,就会在这个位置设置一个保存点.如果B没有问题.执行通过.如果B出现异常,运行客户根据需求回滚(选择回滚到保存点或者是最初始状态)