1、Spring基础概念总结

1. Spring概述：

   1. Spring体系结构

   

2. IOC的概念和作用

   1. 耦合指的是对象之间的依赖关系，耦合越小越好

   2. 以jdbc为例

      1. 通过反射来注册驱动，那么会造成驱动名称写死在程序当中，这种结果显然是不太合理的
      2. 通过配置文件的形式可以解决这种耦合问题

   3. 控制反转模式

      1. 之前程序之间获取对象是通过new的方式
      2. 现在由框架主动线程生成对象，程序被动接受框架生成的对象

   4. IOC作用就是削减计算程序之间的耦合关系

   5. BeanFactory and ApplicationContext的区别

      1. BeanFactory才是Spring容器的顶层接口，Application是BeanFactory的子接口

      2. ApplicationContext只要读取配置文件，默认情况下就会创建对象

      3. BeanFactory 什么时候使用，什么时候在创建对象

      4. ApplicationContext接口的实现类：

         1. ClassPathXmlApplicationContext：是从类的根路径下加载配置文件
         2. FileSystemXmlApplicationContext：是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
         3. AnnotationConfigApplicationContext：当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解

   6. IOC中的bean标签和管理对象细节

      1. bean标签：配置对象给Spring来创建，默认情况下调用的是无参构造函数，如没有无参构造函数则不能创建成功

      2. 实例化对象Bean的三种方式

         1. 使用默认的午餐构造函数：
         2. spring 管理静态工厂-使用静态工厂的方法创建对象
         3. spring 管理实例工厂-使用实例工厂的方法创建对象

      3. 依赖注入

         1. 实现持久层对象传入业务层

         2. 构造函数注入

                   
            <bean id="accountService" class="com.SpringDemo4springDI.service.IAccountServiceImpl">
                    <constructor-arg name="name" value="泰斯特">constructor-arg>
                    <constructor-arg name="age" value="18">constructor-arg>
                    <constructor-arg name="birthday" ref="now">constructor-arg>
                bean>
            

         3. set方法注入

                  
            
            
                <bean id="now" class="java.util.Date">bean> 
            <bean id="accountService2" class="com.SpringDemo4springDI.service.IAccountServiceImp2">
                    <property name="name" value="TEST" >property>
                    <property name="age" value="21">property>
                    <property name="birthday" ref="now">property>
                bean>
            

         4. 集合注入

                
              <bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
                    <property name="myStrs">
                        <set>
                            <value>AAAvalue>
                            <value>BBBvalue>
                            <value>CCCvalue>
                        set>
                    property>
            
                    <property name="myList">
                        <array>
                            <value>AAAvalue>
                            <value>BBBvalue>
                            <value>CCCvalue>
                        array>
                    property>
            
                    <property name="mySet">
                        <list>
                            <value>AAAvalue>
                            <value>BBBvalue>
                            <value>CCCvalue>
                        list>
                    property>
            
                    <property name="myMap">
                        <props>
                            <prop key="testC">cccprop>
                            <prop key="testD">dddprop>
                        props>
                    property>
            
                    <property name="myProps">
                        <map>
                            <entry key="testA" value="aaa">entry>
                            <entry key="testB">
                                <value>BBBvalue>
                            entry>
                        map>
                    property>
                bean>
            

      4. 基于注解实现

         1. Component:用于把当前类对象存入到Spring容器当中

         2. Controller:表现层

         3. @Service 业务层

            1. @Autowired 自动类型注入，只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功；
            2. @Qualifier 用于指定注入bean的id；
            3. @Resource 可独立使用 类似Autowired

         4. @Repository 持久层

      5. 基于注解的IOC配置

         1. 注解解决容易问题

            在测试类中，每个测试方法都有以下两行代码：
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            IAccountService as = ac.getBean("accountService",IAccountService.class);
            这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。
            
            解决方案：
            依靠 spring 框架，因为它提供了一个运行器，可以读取配置文件（或注解）来创建容器。我
            们只需要告诉它配置文件在哪就行
            
            /**
             * 使用Junit单元测试：测试我们的配置
             * Spring整合junit的配置
             *      1、导入spring整合junit的jar(坐标)
             *      2、使用Junit提供的一个注解把原有的main方法替换了，替换成spring提供的
             *             @Runwith
             *      3、告知spring的运行器，spring和ioc创建是基于xml还是注解的，并且说明位置
             *          @ContextConfiguration
             *                  locations：指定xml文件的位置，加上classpath关键字，表示在类路径下
             *                  classes：指定注解类所在地位置
             *
             *   当我们使用spring 5.x版本的时候，要求junit的jar必须是4.12及以上
             @RunWith 注解替换原有的运行器
             @ContextConfiguration 指定Spring配置文件的位置
             @AutoWired给测试类中的变量注入数据
             
             
             */    
                
            @RunWith(SpringJUnit4ClassRunner.class)
            @ContextConfiguration(classes = SpringConfiguration.class)
            public class AccountServiceTst {
            
                @Autowired
                private IAccountService accountService;
            
                @Test
                public void testFindAll(){
                    List<Account> accounts = accountService.findAllAccount();
                    for (Account account : accounts) {
                        System.out.println(account);
                    }
                }
            
            
            }
            
            

3. AOP的相关概念：

   1. AOP 面向切面编程

   2. 使用动态代理技术实现代码运行期间，不修改源码对已有方法进行增强的操作

      private IAccountDao accountDao = new AccountDaoImpl();
          @Override
          public void saveAccount(Account account) {
              try {
                  TransactionManager.beginTransaction();
                  accountDao.save(account);
                  TransactionManager.commit();
              } catch (Exception e) {
                  TransactionManager.rollback();
                  e.printStackTrace();
              }finally {		
              	TransactionManager.release();
          }
      }
      @Override
      public void updateAccount(Account account) {
          try {
              TransactionManager.beginTransaction();
              accountDao.update(account);
              TransactionManager.commit();
          } catch (Exception e) {
              TransactionManager.rollback();
              e.printStackTrace();
          }finally {
              TransactionManager.release();
          }
      }
      // 以上有很多重复的事务代码，需要进一步优化处理
      // 解决方案： 使用动态代理技术解决重复代码问题
      

      public class BeanFactory {
      // 创建代理对象工厂
      
          private IAccountService accountService;
          private TransactionManager transactionManager;
      
          public final void setAccountService(IAccountService accountService) {
              this.accountService = accountService;
          }
      
          public void setTransactionManager(TransactionManager transactionManager) {
              this.transactionManager = transactionManager;
          }
      
      
          public IAccountService getAccountService(){
              return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                      accountService.getClass().getInterfaces(),
                      new InvocationHandler() {
                          @Override
                          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                              if("test".equals(method.getName())){
                                  return method.invoke(accountService,args);
                              }
                              Object returnValue = null;
                              try {
      
                                  transactionManager.beginTransaction();
                                  returnValue = method.invoke(accountService, args);
                                  transactionManager.commit();
                                  return  returnValue;
      
                              }catch (Exception e){
                                  transactionManager.rollback();
      
                                  throw new RuntimeException(e);
                              }finally {
      
                                  transactionManager.release();
                              }
                          }
                      });
          }
      }
      
      

4. Spring 中的 AOP

   1. AOP 相关术语

      1. **Joinpoint(连接点)：所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点；
      2. **Advice(通知/增强)：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知；通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知；
      3. Introduction:运行期为类动态地添加一些方法或Field；
      4. Target: 代理目标的对象；
      5. Weaving：增强应用到目标对象来创建新的代理对象的过程；Spring采用的是动态代理织入；
      6. Proxy：一个类被AOP织入增强后产生一个结果代理类；
      7. 切入点和通知的结合：
      8. 切面通常是需要被增强的野望 代码，
         1. 切入点方法一般是业务层，加强的方法一般是在切入点之前执行并且通过AOP进行配置增强
         2. 增强方式有两种配置通知的类型：1.配置前置通知，后置通知，异常通知，最终通知；2配置环绕通知