1.    Spring简介Spring是一个一站式轻量级框架,解决业务逻辑层和其他层的松耦合问题优点:1.方便解耦,简化开发.通过Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring控制2.AOP编程支持:面向切面编程3.声明式事务的支持4.方便程序测试5.方便集成各种优秀框架6.降低Java EE API的使用难度7.Java源码是经典学习范例.    2.    Spring IoC(Inversion of Control)     对象的控制反转控制反转:将对象的创建权反转给(交给)Spring    业务和实现类太过紧密.传统开发模式:通过工厂模式可实现,接口与实现业务的分离.使用Spring-IoC:添加jar包,创建配置文件,添加配置文件,测试使用    3.    Spring IoC的基本使用创建一个新的project,在idea上面java E下面的Web Application在web下面的web-inf下面新建一个lib的文件夹,添加相关jar包,然后对相关jar包add lib.然后在src下面添加packeg  com.itlike.demo1添加interface  UserDao 添加两个方法save和delete两个class UserDaoMysql和UserDaoOracel,重写save和delete方法.添加测试类 UserTest,写@Test test方法.使用Spring IoC,而不是new一个对象使用方式: 1.添加jar包      2.创建配置文件File,通常名称起为applicationContext.xml,放在src下面      3.添加配置选项.添加
     添加的是id是自己想的一个名字可以随便写,class是接口实现类的地址全路径applicationContext.xml的配置.
     
         
              
               
           
          
          
              
           
          
          
          
      
     添加好了配置文件,需要在test中加载配置文件.(1).加载配置文件先new一个ClassPathXmlApplicationContext("applicationContext.xml");然后ApplicationContext applicationContext = 这个new的对象.(2).根据id获取对象        UserDaoMysqlImpl userDaoXml = (UserDaoMysqlImpl) applicationContext.getBean("userDaoXml");        userDaoXml.save();        userDaoXml.delete();            //(需要对.getBean进行强制类型转换)由于面向接口的原因,上面UserDaoMysqlImpl是UserDao的一个是类,所以使用UserDao的方法把UserDaoMysqlImpl都换成UserDao.变成如下:        UserDao userDaoXml = (UserDao) applicationContext.getBean("userDaoXml");        userDaoXml.save();        userDaoXml.delete();以后如果需要改变为Oracel只需要改变applicationContext.xml的bean的class就行了.idea通过右键generate getter and setter添加get和set方法.idea快捷键alt+insert添加各种方法.setter getteridea使用Ctrl+O，重写方法快捷键.IoC与DI:依赖注入前提必须有IOC的环境,Spring管理这个类的时候才能将类的依赖的属性值注入（设置）进来依赖注入:给spring管理类当中依赖的属性,通过配置文件进行赋值的过程    4.    Spring-DI依赖注入依赖注入前提必须有IOC的环境Spring管理这个类的时候才能将类的依赖的属性值注入（设置）进来接上课,如果一个类已经交给Spring来管理了,那么这个类里面可能还有其他的属性.比如里面还有一个String name.那么这个类就依赖于这个name的属性,给spring管理类当中依赖的属性,通过配置文件进行赋值的过程就称为依赖注入常规的赋值方式    @Test    public void test2(){        //常规的方式进行赋值        UserDaoMysqlImpl userDaoMysql=new UserDaoMysqlImpl();        userDaoMysql.name="xxx";        System.out.println(userDaoMysql.name);    }使用依赖注入的方式.该属性需要有setter方法,在application.xml里的bean的里面添加一个
     
      name为该属性的名字,value为你要赋的值.
          
           
       
      创建一个test2    @Test    public void test2(){        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");        UserDaoMysqlImpl B = (UserDaoMysqlImpl) applicationContext.getBean("userDaoXml");        System.out.println(B.name);    }name的值通过.xml配置的方式进行赋值.注意:1.实现类当中的属性要提供set方法 2.在配置文件当中配置依赖注入    5.    Spring-工厂类BeanFactory老版本使用方式,在以前当调用getBean的时候才会创建实例对象现在使用的是ApplicationContext 新版本使用方式,当加载配置文件时候就会创建实例对象ApplicationContext实现类  ClassPathXmlApplicationContext加载类路径下的配置文件//一般的使用方式.FileSystemXmlApplicationContext加载文件系统下的配置文件    6.    Spring-Bean对象生命周期Bean的相关配置.    
              
           
      名称与标识id使用了约束中的唯一约束。里面不能出现特殊字符的name没有使用约束中的唯一约束。里面可以出现特殊字符。设置对象的生命周期方法init-Method Bean被初始化的时候执行的方法destroy-Method Bean被销毁的时候执行的方法（Bean是单例创建，工厂关闭）使用application.close()实现关闭的时候调用destroy-Method方法.单例工厂关闭的时候,里面所有的对象都会销毁.    7.    Spring-bean对象的作用范围作用范围的配置scopesingleton 默认的，Spring会采用单例模式创建这个对象。prototype 多例模式。request 应用在web项目中，Spring创建这个类以后，将这个对象存入到request范围中。session 应用在web项目中，Spring创建这个类以后，将这个对象存入到session范围中.globalsession 应用在web项目中，必须在porlet(基于Java的Web组件，子域名)环境下使用。但是如果没有这种环境，相对于session。singleton 使用单例:关闭工厂  (所有的对象都 会销毁)使用多例时,关闭工厂时不会销毁.    8.    Spring-工厂实例化方式无参构造-默认执行的    public Person(){        super();        System.out.println("执行了Person无参方法");    }静态工厂实例化在applicationContext.xml里的bean里配置factory-method="creatPerson"在person里添加必须是public static静态的 Person返回值必须为该类 createPerson()自己命名的方法   public static Person createPerson(){        System.out.println("createUser");        return new Person(); }实例工厂实例化在applicationContext.xml里配置
      
      添加test   ApplicationContext applicationContext =   new ClassPathXmlApplicationContext("applicationContext2.xml");   Person person=(Person)applicationContext.getbean("person2");   System.out.println(person);    9.    Spring-分模块配置在加载时，添加多个配置文件名称        ApplicationContext applicationContext=        new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");在一个配置文件当中引入另一个配置文件在applicationContext.xml里添加导入其他的applicationContext.    
          
          
          10.    Spring-构造方法式属性注入构造方法的方式的属性注入在class类里添加构造方法    public Student(String name, Integer age){        this.name = name;        this.age = age;    }在配置文件的bean下面添加
          
           
       
      Set方法的属性注入通过在class类里添加属性的setter方法,在.xml配置文件内添加property name="属性名" value="赋值"实现属性注入.    11.    Spring-引用类型属性注入Set方法设置对象类型的属性如果student类型中的某个属性是非基本类型,而是依赖于其他类的一个属性.添加       
          
           
      在引用    
              
               
               
           
      注意:在两个类中都需要添加setter方法,在property里不是使用value赋值而是添加ref引用.也可以重写dog类里面的toString方法,直接ref="dog"输出重写方法.    12.    Spring-p名称空间属性注入P名称空间的属性注入,使用p名称空间，就不需要写那那么多的property,减少属性注入.使用时，在beans里要添加名称空间,xmlns:p="http://www.springframework.org/schema/p"再在bean下面使用P名称空间进行配置就行    
          
      test下面添加测试    Dog student2=(Dog)applicationContext.getBean("dog2") ;    System.out.println(student2);而且引用ref也可以使用    
      p:dog-ref="dog2"表示Student里的dog属性引用dog2的bean配置    13.    Spring-spEL表达式属性注入    
              
               
               
           
      格式value="#{}" 字符串就使用''添加在{}里面,如果是数字就直接添加在{}里面.还可以使用spEL表达式注入添加代替引用        
              
          14.    Spring-集合类型属性注入数组类型集合
     

 

在class里添加数组attr和setter方法,重写toString然后在applicationContext.xml里添加配置    
             
                  
                       
        
         a
                        
        
         b
                        
        
         c
                    
               
      list集合的添加注入类似于数组添加list属性和setter,添加配置同上. List:  它是一个有序的集合(元素存与取的顺序相同)  它可以存储重复的元素 Set:  它是一个无序的集合(元素存与取的顺序可能不同)  它不能存储重复的元素set集合的添加注入方法添加set属性和它的setter,添加配置        
                  
                       
        
         set a
                        
        
         set b
                        
        
         set c
                    
               
      Map集合添加map属性和它的setter,添加配置        
                  
               
          15.    Spring-IoC注解开发在spring4之后，想要使用注解形式，必须得要引入aop的包-->Spring-aop-5.0.7.RELEASE.jar在配置文件当中，还得要引入一个context约束配置组件扫描,哪个包下的类型使用组合扫描
      
      
          
           
       
      在类开上添加注解@Component("user")相当于在.xml里配置的
      
       @Component("user")public class User {    public void say(){        System.out.println("hello");    }}使用注解注入属性,可以不用提供set方法，直接在直接名上添加@Value("值")    @Value("myxq")    private String name;如果提供了set方法，在set方法上添加@Value("值");    private String name;    @Value("myxq")    public void setName(String name) {        this.name = name;    }    16.    Spring-注解引用类型属性注入@Component  修改一个类，将这个类交给Spring管理  相当于在配置文件当中配置
       
        为了更好的进行分层，Spring可以使用其它三个注解，功能类似,目前使用哪一个功能都一样,后期可能会添加一些属于各自的属性.@Controller对应web层@Service对应service层@Repository对应dao层@Value 设置普通属性值注入引用类型的3种方式.第1种方式  @Autowired 设置对象类型的属性值 直接使用这种方式，是按照类型完全属性注入不需要在注解上使用id名称创建一个class类@Component("dog")public class Dog {    @Value("sang")    public String name;}在User里添加    @Autowired    public Dog abc;test里添加    System.out.println(user.abc.name);注意需要添加Dog类的注解@Component,表示这个类归Spring进行管理,但是可以不添加@Component的值.@Autowired会自动到Spring中寻找Dog这个类.@Autowired就是根据类型进行注入第2种方式  习惯是按照名称完成属性注入,必须让@Autowired注解与@Qualifier一起使用 @Autowired @Qualifier("dog")    //根据名称进行注入 public Dog dog;第3种方式  单独使用@Resource    @Resource(name = "dog")    //这就是@Component("dog")相当于bean的id    public Dog abc;    17.    Spring-生命周期注解形式@PostConstruct 初始化方法 相当于.xml里配置的init-method@PreDestroy  销毁方法    相当于.xml里bean配置的destroy-method@scope 作用范围 相当于.xml里的scope  作用范围,单例singleton 多例prototype注意使用单例:关闭工厂(所有的对象都 会销毁)   使用多例时,关闭工厂时不会销毁.    18    Spring-xml配置与注解结合XML与注解比较,XML可以适用任何场景,结构清晰,维护方便, 注解不是自己提供的类使用不了，开发简单方便,注入简单XML与注解整合开发,XML管理Bean,注解完成属性注入,使用过程中,可以不用扫描,扫描是为了类上的注解不添加
        的情况下在没有扫描的情况下添加.xml里
        ， 使用属性注解@Resource @Value @Autowired @Qulifier
       
      
     

19    Spring-服务层与dao层传统写法    20.    Spring-服务层与dao层spring配置写法        impl=implement 实施，执行;1.配置.xml配置2个bean然后service引用dao方法   
         
         
             
          
     2.在UserServiceImpl里添加userDao和setter方法.public class UserServiceImpl implements UserService{    private UserDao userDao;    public void setUserDao(UserDao userDao) {        this.userDao = userDao;    }    @Override    public void delete() {        userDao.delete();    }}3.在UserTest中导入配置,然后使用service.delete()    @Test    public void test()    {        ApplicationContext applicationContext= new ClassPathXmlApplicationContext("applicationContext.xml");        UserServiceImpl service=(UserServiceImpl)applicationContext.getBean("service");        service.delete();    }    21.    Spring-服务层与dao层spring注解式写法在.xml里添加一个扫描    
     在服务层添加@Service("service")在Dao层添加@Repository("dao")在服务层添加    @Autowiredprivate UserDao userDao;当Dao层只有一个bean时,直接使用@Autowired,如果有多个bean时,需要使用@Qualifier("dao")指定使用的bean.或者使用@Resource(name="dao2")    22.    Spring-AOP简介在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP采用了横向抽取机制取代了传统纵向继承.不破坏原理的类,生成一个代理类,在原来类的基础上进行增强,可以随时添加,取消添加操作.核心就是使用动态代理.    23.    Spring-AOP内部原理JDK动态代理JDK动态代理必须依赖于接口.当使用接口的时候,自动调用JDK动态代理,而添加一个GoodsJDKProxy代理类,使用代理类来处理.public class GoodsJDKProxy {    public GoodsDao createProxy(GoodsDao goodsDao){        //增强        GoodsDao goodsDaoProxy =(GoodsDao) Proxy.newProxyInstance(goodsDao.getClass().getClassLoader(),                goodsDao.getClass().getInterfaces(),                new InvocationHandler() {                    @Override/*当调用对象的时候 , 所有的方法都会来到这里*/                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        if("save".equals(method.getName()))                        {                            System.out.println("调用权限校验");                            return method.invoke(goodsDao,args);                        }                        return method.invoke(goodsDao,args);                    }                });     return goodsDaoProxy;    }}GoodsDaoTest代码    @Test    public void test() {        GoodsDao goodsDao = new GoodsDaoImpl();//        goodsDao.save();        GoodsJDKProxy goodsJDKProxy=new GoodsJDKProxy();        //获取的代理对象        GoodsDao proxy=goodsJDKProxy.createProxy(goodsDao);        proxy.save();        proxy.update();    }

24.    Spring-AOP内部原理Cglib动态代理Cglig是一个第三方开源代码 生成类库，动态添加类的属性和方法。在spring的核心包当中已经引入了cglib,采用的是继承方式来产生的代理对象.没有接口时自动选择cglib提供一个class,而不是接口public class UserDao {    public void save(){        System.out.println("保存");    }    public void update(){        System.out.println("更新");    }}Test文件public class UserDaoTest {    @Test    public void test(){        UserDao userDao=new UserDao();        //增强        UserDaoCglibProxy userDaoCglibProxy=new UserDaoCglibProxy();        UserDao cglibProxy=userDaoCglibProxy.createCglibProxy(userDao);        cglibProxy.save();    cglibProxy.update();    }}添加一个UserDaoCglibProxy代理类public class UserDaoCglibProxy {    public UserDao createCglibProxy(UserDao userDao){        //1.创建一个核心类        Enhancer enhancer=new Enhancer();        //2.设置父类 使用继承方式 创建一个子类自动继承UserDao        enhancer.setSuperclass(userDao.getClass());        //3.设置回调        enhancer.setCallback(new MethodInterceptor() {            @Override            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                if ("save".equals(method.getName()))                {                    System.out.println("权限认证");                    return methodProxy.invokeSuper(o,objects);                }                return methodProxy.invokeSuper(o,objects);            }        });        //4.创建代理对象 就是把子类给你        UserDao obj =(UserDao) enhancer.create();        return obj;    }}AOP思想最早是由AOP联盟组织提出的,Spring使用这种思想最好的框架AspectJ,Spring的AOP有自己的实现方式，但是这种方式非常繁琐AspectJ 是一个AOP的框架,Spring放弃了自己传统的方式 ，引入AspectJ作为自身AOP的开发    25.    Spring-AOP相关术语(1).Joinpoint:连接点,可以被拦截到的方法,能够被增强的方法，这些方法就可以称为是连接点public class UserDao {    public void save(){}    public void update(){}}这个save()和update()方法就称为连接点.(2).Pointcut:切入点,真正被拦截的方法,真正被增加的方法.如上面我们在代理对象里给save()方法添加了一个权限检查功能,这个save()方法就称为切入点.(3).Advice：通知.增加的内容，通常都是封装成一个方法， 这个方法我们就称为通知比如上面给save()添加的权限检查功能(4).Introduction:引介 类层面的增加  给原有的类添加一些新的属性方法 在开发中通常都是给方法进行增加比如给上面的UserDao内部添加的一个public void delete()方法.这个delete方法就称为引介(5).Target:被增加的对象.需要增强的对象,这个UserDao就称为Target(6).Weaving:织入 将通知应用到目标对象的过程,给切入点添加通知的过程(7).Proxy:代理对象(8).Aspect:切面 多个通知和多个切入点的集合    26.    Spring-spring-test使用1.引入spring基本jar包2.引入aop开发的相关jar包3.配置文件中引入aop约束配置applicationContext.xml的beans.
     4.Spring测试时，每次都需要获取工厂 通过spring-test，就不用每次获取添加测试依赖包spring-test-5.0.7.RELEASE.jar.5.测试@RunWith(SpringJUnit4ClassRunner.class)                   //让测试运行于spring测试环境@ContextConfiguration("classpath:applicationContext.xml") //指定 Spring 配置文件所在的位置public class AopTest {    @Autowired    @Qualifier("goodsDao")     //或者使用@Resource(name="goodsDao")用于注入其他非基本类的属性    private GoodsDao goodsDao;    @Test    public void test(){        goodsDao.save();        goodsDao.update();    }}}}        27    Spring-AOP配置上一章配置好测试环境.6.编写一个切面类public class Myaspect {    public void checkPrivilege(){        System.out.println("权限认证");    }}7.将切面交给spring    
         
     8.配置AOP完成对目标产生代理    
             
              
           //*代表任意方式都可以        
                                       //..代表任意参数都行        
              
                   
               
          
     

 

28.    Spring-AOP通知类型前置通知 aop:before:在目标方法执行之前,进行操作
     
     后置通知 aop:after-returning 在目标方法执行之后 进行操作   
     
     通知     public void log(Object res){         System.out.println("日志记录"+res);     }环绕通知 aop:around 在目标方法执行之前 和之后进行操作.还可以阻止原方法的执行
     
     通知    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {        System.out.println("开启事务");        Object proceed = joinPoint.proceed();        //此处继续执行delete操作,如果没有这句将不执行delete操作        System.out.println("提交事务");        return  proceed;    }异常抛出通知 aop:after-throwing 在程序出现异常时进行操作,除了异常时执行,还可以获取信息
     
     通知    private void exceptionM(Throwable ex){        System.out.println("异常终止"+ex.getMessage());    }最终通知 aop:after 无论代码是否有异常，都会执行
     通知    public void endding(){        System.out.println("终止操作");    }    29.    Spring-AOP切入点表达式基于execution函数完成语法【访问修饰符】 方法返回值 包名.类名.方法名（参数）public com.myxq.demo2.GoodsDaoImpl.save(..)  参数为任意参数* com.myxq.demo2.GoodsDaoImpl.save(..)  *  任意类型* com.myxq.demo2.GoodsDaoImpl+.save(..)  + 当前类和子类* com.myxq..*.*(..) com.myxq包以及子包下面所有类的所有方法    30.    Spring-AOP注解形式1.引入Jar包    2.引入配置文件    3.编写切面类配置.xml里添加管理创建切面public class GoodsDaoAspect {    public void log(){        System.out.println("日志");    }}    
     4.使用注解的AOP对象目标类进行增强在applicationContext.xml里配置aop注解自动开启    
         
     然后在切面类上添加注解@Aspectpublic class GoodsDaoAspect {    @Before(value = "execution(* com.itlike.deom1.GoodsDaoImpl.save())")    public void log(){        System.out.println("日志");    }}    31.    Spring-AOP注解形式通知类型注解AOP通知类型@Before就是前置通知@AfterReturning后置通知 没有返回值    @AfterReturning(value = "execution(* com.itlike.deom1.GoodsDaoImpl.update())")    public void houzhi(){        System.out.println("后置");    }有返回值的情况    @AfterReturning(value = "execution(* com.itlike.deom1.GoodsDaoImpl.update(..))",returning ="Res")    public void houzhi(Object Res){        System.out.println("后置"+Res);    }@Around环绕通知    @Around(value = "execution(* com.itlike.deom1.GoodsDaoImpl.delete(..))")    public Object Around(ProceedingJoinPoint joinPoint) throws Throwable {        System.out.println("环绕前.");        Object obj = joinPoint.proceed();        System.out.println("环绕后.");        return obj;    }@AfterThrowing异常抛出通知没有获取异常信息 获取异常信息    @AfterThrowing(value = "execution(* com.itlike.deom1.GoodsDaoImpl.find(..))",throwing = "ex")    public void afterThrowing(Throwable ex){        System.out.println("异常"+ex);    }@After最终通知    @After(value="execution(* com.itlike.deom1.GoodsDaoImpl.find(..))")    public void after(){        System.out.println("最终通知");    }    32.    Spring-AOP内部代理机制    @Before(value = "execution(* com.itlike.deom1.GoodsDaoImpl.save(..)) ||            execution(* com.itlike.deom1.GoodsDaoImpl.update(..))")    public void log(){        System.out.println("日志");    }AOP的注解切入点的配置使用，有时候一个方法要添加前置通知对又要添加异常通知，又要添加最终通知可以在切面当中定义好切入点，在通知当中直接使用定义好的切入点表达式。    @Pointcut(value = "execution(* com.itlike.demo1.GoodsDaoImpl.save(..))")    private void pointcut1(){}    @Pointcut(value = "execution(* com.itlike.demo1.GoodsDaoImpl.update(..))")    private void pointcut2(){}    @Pointcut(value = "execution(* com.itlike.demo1.GoodsDaoImpl.delete(..))")    private void pointcut3(){}    @Pointcut(value = "execution(* com.itlike.demo1.GoodsDaoImpl.find(..))")    private void pointcut4(){}    @Pointcut(value = "execution(* com.itlike.demo1.UserDao.save(..))")    private void pointcut5(){}定义多个切入点，一个通知同时定义到多个方法当中    @Before(value = "GoodsDaoAspect.pointcut1() || GoodsDaoAspect.pointcut4() || GoodsDaoAspect.pointcut5()")    public void log(){        System.out.println("日志");    }    @AfterReturning(value = "GoodsDaoAspect.pointcut2()",returning = "res")    public void afterreturning(Object res){        System.out.println("后置通知---"+res);    }当使用接口时与不使用接口内部代理区别，使用接口。使用接口时采用JDK动态代理，不是接口时使用Cglib.

33.    Spring-JDBC模板使用Spring的JDBC的模板,Spring是EE开发的一站式的框架，有EE开发的每层的解决方案。Spring对持久层也提供了解决方案：ORM模块和JDBC的模板。Spring提供了很多的模板用于简化开发,JDBC(org.springframework.jdbc.core.jdbc.jdbcTemplate)和Hibernate(orm.springframework.orm.hibernamte.HibernateTemplate)JDBC模板使用的入门,引入jar包spring开发基本jar包,数据库驱动,Spring的JDBC模板的jar包创建数据库和表create table account(    id int primary key auto_increment,    name varchar(20),    money double);使用JDBC的模板public class SpringJdbcTest {    @Test    public void test() {        //创建连接池        DriverManagerDataSource dataSource = new DriverManagerDataSource();        dataSource.setDriverClassName("com.mysql.jdbc.Driver");        dataSource.setUrl("jdbc:mysql:///spring");        dataSource.setUsername("root");        dataSource.setPassword("cqkill000");        //创建jdbc模板        JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);        jdbcTemplate.update("insert into account values (null ,?,?)","itlike",1000d);    }}    34.    Spring-JDBC模板改写将连接池和模板交给Spring管理,配置文件配置Bean配置的beans
     配置Bean    
             
              
              
              
          
         
             
          //使用ref,因为非基本类型的注入    
     使用jdbcTemplate注解插入数据@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class SpringJdbcTest2 {//    @Autowired//    @Qualifier("jdbcTemplate")    @Resource(name = "jdbcTemplate")    private JdbcTemplate jdbcTemplate;    @Test    public void test(){        jdbcTemplate.update("insert into account values (?,?,?)",2,"chen",101);    }}    35.    Spring-JDBC第三方连接池配置DBCP 引入jar包com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jarcom.springsource.org.apache.commons.pool-1.5.3.jar配置DBCP连接池     
         
             
              
              
              
          
         
             
          
     C3P0配置    
         
             
              
              
              
          
         
             
          
     DRUID配置        //阿里巴巴的开源连接池,目前性能最好?    
         
             
              
              
              
          
         
             
          
         36.    Spring-加载properties属性文件创建一个file文件jdbc.propertiesdriverClass=com.mysql.jdbc.Driverurl=jdbc:mysql:///springusername=rootpassword=cqkill000加载属性文件,使用
     
      方式.    
              
           
          
          
              
               
               
               
           
      加载属性文件,使用
      方式修改jdbc.properties里的配置,由于
      jdbc.driverClass=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql:///springjdbc.username=rootjdbc.password=cqkill000使用
      方式    value值 不能和name一样    
          
          
              
               
               
               
           
      
     

37.    Spring-JDBC模板CRUD操作插入操作jdbcTemplate.update("insert into 表名 value(?,?,?)",1,"xxx",123);    //?占位符删除操作jdbcTemplate.update("delete from 表名 where id=?",13);更新操作jdbcTemplate.update("update 表名 set name=?,money=? where id=?","xxx",120,2);    //where前面没有逗号.查询操作 查询某一个字段    public void test4(){    //String.class 查询结果的类型        String name=jdbcTemplate.queryForObject("select name from account where id =?",String.class,3);        System.out.println(name);    }查询count    @Test    public void queryCount(){        Long count=jdbcTemplate.queryForObject("select count(*) from account",Long.class);        System.out.println(count);    }    38.    Spring-JDBC模板查询所有查询操作 查询一个对象,返回对象的集合先建立一个简单的pojo类Account,添加它的set和get方法,已经重写toString方法.public class Account {    private Integer id;    private String name;    private Double money;}    @Test    public void queryAccount(){        Account account=jdbcTemplate.queryForObject("select * from account where id=?",new MyRowMap(),2);        System.out.println(account);    }class MyRowMap implements RowMapper
     
      {    @Override    public Account mapRow(ResultSet resultSet, int i) throws SQLException {        Account account=new Account();        account.setId(resultSet.getInt("id"));        account.setName(resultSet.getString("name"));        account.setMoney(resultSet.getDouble("money"));        return account;    }}查询多个对象,返回对象的集合    @Test    public void queryAllAccount(){        List
      
        query=jdbcTemplate.query("select *from account",new MyRowMap());        for (Account a:query){            System.out.println(a);        }    }    39.    Spring-事务概述什么是事务:逻辑上的一组操作，组成这组操作的各个单元，要么全都成功，要么全都失败。事务的特性:ACID性质.1.原子性 Atomicity：事务不可分割2.一致性 Consistency：事务执行前后数据完整性保持一致3.隔离性 Isolation：一个事务的执行不应该受到其他事务的干扰.4.持久性 Durability：一旦事务结束，数据就持久化到数据库.如果不考虑隔离性引发安全性问题读问题:1.脏读        ：一个事务读到另一个事务未提交的数据2.不可重复读    ：一个事务读到另一个事务已经提交的update的数据，导致一个事务中多次查询结果不一致3.虚读、幻读    ：一个事务读到另一个事务已经提交的insert的数据，导致一个事务中多次查询结果不一致。写问题:丢失更新.解决读问题,设置事务的隔离级别1.可读取未提交 Read uncommitted    ：未提交读，任何读问题解决不了。2.可读已提交 Read committed    ：已提交读，解决脏读，但是不可重复读和虚读有可能发生。    Orical默认级别3.可重复读 Repeatable read    ：重复读，解决脏读和不可重复读，但是虚读有可能发生。    MySQL默认级别4.序列化 Serializable        ：解决所有读问题。    性能损耗大    Spring的事务管理的API1.PlatformTransactionManagerPlatformTransactionManage:平台事务管理器 是一个接口,下面有两个实现类1.DataSourceTransactionManager,底层使用JDBC管理事务.2.HibernateTransactionManager,底层使用Hibernate管理事务.TransactionDefinition:事务定义信息:用于定义事务的相关的信息，隔离级别、超时信息、传播行为、是否只读TransactionStatus:事务状态：用于记录在事务管理过程中，事务的状态的对象。事务管理的API的关系:Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态的对象中。    40.    Spring-事务传播行为什么是传播行为,一个业务方法当中,调用另一个业务的方法.Spring中提供了七种事务的传播行为:保证多个操作在同一个事务中:1.PROPAGATION_REQUIRED        默认值，如果A中有事务，使用A中的事务，如果A没有，创建一个新的事务，将操作包含进来2.PROPAGATION_SUPPORTS        支持事务，如果A中有事务，使用A中的事务。如果A没有事务，不使用事务。3.PROPAGATION_MANDATORY        如果A中有事务，使用A中的事务。如果A没有事务，抛出异常。保证多个操作不在同一个事务中:4.PROPAGATION_REQUIRES_NEW    如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作。                如果A中没有事务，创建一个新事务，包含自身操作。5.PROPAGATION_NOT_SUPPORTED    如果A中有事务，将A的事务挂起。不使用事务管理。6.PROPAGATION_NEVER        如果A中有事务，报异常。嵌套式事务:7.PROPAGATION_NESTED        嵌套事务，如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点                执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点    41.    Spring-事务问题搭建Spring事务管理环境:1.创建AoccuntDao2.实现Dao接口3.把Dao交给Spring管理5.在Dao中注入数据源,在DAO当中注入jdbc模板,要保证dao继承了JdbcDaoSupportpublic class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{//    private JdbcTemplate jdbcTemplate;////    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {//        this.jdbcTemplate = jdbcTemplate;//    }继承之后, 就有了datasource的set方法,就可以注入了通过两步注入    
               
            
           
           
               
            
       Dao继承JdbcDaoSupport,DAO注入JDBC模板直接使用继承的JdbcDaoSupport里面的dataSource    
           
               
            
       6.创建Account业务public class AccountServiceImpl implements AccountService{    private AccountDao accountDao;    public void setAccountDao(AccountDao accountDao) {        this.accountDao = accountDao;    }    @Override    public void transferMoney(String from, String to, Double money) {        this.accountDao.addMoney(to,money);        this.accountDao.minusMoney(from,money);    }}7.配置service 交给spring 并注入dao    
           
               
            
           
           
               
            
       8.测试@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration("classpath:applicationContext.xml")public class AccountTest {    @Resource(name="accountService")    private AccountService accountService;    @Test    public void Test(){        accountService.transferMoney("c3p0" ,"chen",100d);    }}
      
     

42.    Spring-编程式事务需要手动编写代码配置平台事务管理器
       
         
        
     Spring提供了事务管理的模板类 
       
         
        
     在业务层注入事务管理的模板    
         
             
              
          
     编写事务管理的代码    private TransactionTemplate transactionTemplate;    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {        this.transactionTemplate = transactionTemplate;    }    @Override    public void transferMoney(String from, String to, Double money) {        this.transactionTemplate.execute(new TransactionCallbackWithoutResult() {            @Override            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {                accountDao.addMoney(to,money);                int i=1/0;                accountDao.minusMoney(from,money);            }        });    43.    Spring-声明式事务XML方式引入aop的开发包在beans中添加 xmlns:tx="http://www.springframework.org/schema/tx" xsi:   http://www.springframework.org/schema/tx        http://www.springframework.org/schema/tx/spring-tx.xsd配置事务管理器
         
        
     AOP的配置
         
            
           
        
         
         
             
              
          
         44.    Spring-声明式事务注解方式添加配置事务管理器
         
        
     开启注解事务    
         
     在业务层添加注解@Transactional        //在此可以添加参数就是7种事务传播的方式public class AccountServiceImpl implements AccountService {    private AccountDao accountDao;    public void setAccountDao(AccountDao accountDao) {        this.accountDao = accountDao;    }    @Override    public void transferMoney(String from, String to, Double money) {                accountDao.addMoney(to,money);                accountDao.minusMoney(from,money);    }}    45.    Spring-整合web项目解决方案在Servlet当中直接加载配置文件,获取对象存在问题每次请求都会创建一个Spring的工厂，这样浪费服务器资源，应该一个项目只有一个Spring的工厂。在服务器启动的时候，创建一个Spring的工厂。创建完工厂，将这个工厂类保存到ServletContext中。每次使用的时候都从ServletContext中获取。解决方案    使用spring核心监听器ContextLoaderListener    1.引入jar包 spring-web.jar    2.配置监听器                     
                     
                         
      
       org.springframework.web.context.ContextLoaderListener
                      
                                 
                     
                         
      
       contextConfigLocation
                          
      
       classpath:applicationContext.xml
                      
         3.直接在Action当中获取工厂    46.    Spring-整合web项目代码实现在wem.xml下面添加监听器的配置 
         
             
      
       org.springframework.web.context.ContextLoaderListener
          
         
         
             
      
       contextConfigLocation
              
      
       classpath:applicationContext.xml
          
     ContextLoaderListener的作用就是启动Web容器时，自动装配ApplicationContext.xml的配置信息。在servlet里写        ServletContext sc = this.getServletContext();        /*获取工厂    程序启动的时候  保存到serServletContext*/        WebApplicationContext applicationContext= WebApplicationContextUtils.getWebApplicationContext(sc);        /*获取对象*/        UserService accountService=(UserService)applicationContext.getBean("accountService");        accountService.save();通过监听的形式去获取配置文件