1.Spring是什么?

       Spring就是用来解决对象的创建和对象之间的依赖关系的 这样一门技术。

    Spring能干什么?

        1>:创建对象

        2>:依赖关系

        3>:为service提供事务

        4>:整合我们的传统开发框架

 

2.事务:

    1>:粗粒度事务

         只能够对方法进行添加事务 这种称为粗粒度事务（Spring的事务只能够是粗粒度的事务）

          以后我们在给访问数据库添加事务的时候是不会将事务写到dao层上的，  因为一个动作是否完成取决于业务逻辑是否完成 ，所以事物都是添加在service上的

   2>:细粒度事务

         就是一个事务能够对我们的程序的某几行提供的事务

   3>:事务的分类

      1>:本地事务

       就是只是对一个数据库添加的事务，   我们目前学习的都叫本地的事物

      2>:全局事务

       举例:银行转账 --中国银行给建设银行转钱 。  这个是两个不同的数据库 ，要同时保证在这两 个表中的操作能够顺利的进行，就必须要使用全局事务

3.Spring的模块图（7个）

 

1.Spring AOP模块

     AOP:面向切面的编程

              就是将重复代码抽取出来形成切面类 ，然后当我们程序运行的时候，通过 动态代理或者cglib代理来完成代码的自动植入 的这样一个编程思想 就叫做面向切面的编程

2.Spring ORM模块

      主要是提供了对Hibernate/MyBatis/JDO其他ORM框架整合的支持（对象关系映射）

3.Spring DAO模块

     这个模块实际上是 Spring提供的一个dao层的解决方案(dbutils这种)

4.Spring WEB模块

     这个是Spring提供的对web的支持

5.Spring Context模块

      Spring提供的一个对上下文的支持

6.Spring WEB MVC模块

      这个模块实际上就是传说中的 Spring MVC

7.Spring Core模块

      在我们的Spring中提供了两个思想：  IOC  /  DI

   

        IOC----->表示的是控制反转（inversion  of  control）

        DI ----->依赖注入 (dependcy  injecte)

     反转的是什么?

         1>:以前我们在使用MVC模式来进行开发的时候 service对象是谁创建的?dao对象是谁创建的? 以前我们要使用这个任意类的对象 --->自己通过程序去new一个

         2>:学习了IOC之后那么以后我们的对象的创建就不是我们去完成了,而是由Spring的IOC容器去完成

               那么反转的是什么? 反转的是创建对象的这个权利-----------以前我们自己创建，现在Spring的IOC容器去给我们创建；

               具体控制的是什么? 控制的是创建对象。

 

       依赖注入：注入的是什么?

        依赖表示的是什么意思?谁依赖谁?

        谁依赖谁? 最经典的:controll依赖于service ，service依赖于dao

        依赖注入? 注入的是什么? 注入的是 对象 还有 普通的资源(字符串/boolean/int/float/double)

        控制反转和依赖注入的核心功能包就是:Spring core模块完成的功能

 

4.使用Spring编写一个HelloWorld程序

      1>: 编写程序的第一步:百度下载jar包   spring-framework-4.3.7.RELEASE-dist.jar

      2>:在工程中导入这个包

         commons-logging-1.1.3.jar --->依赖包 日志相关包，是用来辅助运行的

         spring-beans-4.3.7.RELEASE.jar --->实体生成对象的包

         spring-context-4.3.7.RELEASE.jar --->上下文相关包

         spring-core-4.3.7.RELEASE.jar --->核心功能包

         spring-expression-4.3.7.RELEASE.jar --->表达式相关的包

      3>:在我们的src目录下 新建一个文件这个文件的名字是 ApplicationContext.xml这个文件(名字呢实际上是可以随便写)/bean.xml

 

      4>:配置我们约束

         在我们的下载包里面去找spring的配置文件 打开htmlsingle -->xmlns:p 找个长的 copy过来将bean中的所有的东西删除

      5>:使用API获取这个对象

        第一种模式

public void test() throws Exception {//有两种模式来获取这个JAVA对象	//第一种 通过工厂模式来获取JAVA对象//框架默认的路径就在src下ClassPathResource resource=new ClassPathResource("bean.xml");//获取这个工厂XmlBeanFactory factory=new XmlBeanFactory(resource);//第三步:获取这个JAVA对象User user=(User) factory.getBean("user_01");System.out.println(user);}

       第二种模式

public void test2() throws Exception {	ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");//第三步:获取这个JAVA对象User user=(User) context.getBean("user_01");System.out.println(user);}

5.Spring的IOC/DI配置文件

   现在这个对象默认是没有构造函数/没有说明到底是单例的与否....

     1>:默认情况下 生成的JAVA对象是单例的

        配置：

       自动生成对象：

       scope="prototype":这个就表示的是多例的

       scope="singleton":这个表示的是单例的

       lazy-init:表示的是是否延迟创建对象 ，这个只是对单例有效  ，如果不延迟创建那么在web工程中启动工程就会自动创建 ，如果延迟那么表示的是使用的时候才创建对象

        destroy-method="destoryBobo"：销毁方法

       init-method="initBobo"：初始化方法

       <bean id="user_01" class="com.qf.helloword.User" scope="singleton" lazy-init="false" init-method="initBobo" destroy-method="destoryBobo"></bean>

        假设我想给我们的对象赋值 怎么办？

调用有参数的构造器
     
      
      
      
     

        下面引用字符串：

         工厂的模式来创建对象

     
     
     
     
     
     
      接下来我们研究下获取对象的APIClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");//第三步:获取这个JAVA对象//如果使用了类型来找这个对象的话那么 在IOC容器里面就只能有一个类型的对象才能找到//User user=(User) context.getBean(User.class);//通过名字来找 最稳定的//	User user=(User) context.getBean("user_01");//System.out.println(user);注意:使用Spring的时候 默认调用的是无参数的构造参数

 

　　

DI的配置

set 方法进行注入

1>:在需要对象的地方申明我们的类的成员变量

//Set注入的第一步:申明成员变量private UserDao userDao=null;//第二步:为成员变量生成set方法public void setUserDao(UserDao userDao) {this.userDao = userDao;}//第三步:在我们的bean.xml中进行如下配置
     
     
     
     
      
      
     

　　

p标签进行注入

1>:在需要对象的地方申明我们的类的成员变量

//Set注入的第一步:申明成员变量private UserDao userDao=null;//第二步:为成员变量生成set方法public void setUserDao(UserDao userDao) {this.userDao = userDao;}
     
     内部bean的形式进行注入(基本不用)
     
     
      
       
      
     自动装配
     
     
     
     
     
     还可以设置全局的自动装配

注解模式的使用

1>:配置扫描器

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

2>将对象放置到IOC容器呢?

@Component @Service @Repository

3>:注对象

@Resource @Autowired

 

注意: 在业务逻辑层推荐使用 @Service

              在dao层推荐使用 @Repository

 

2017-09-13  01:25:06

 

 6.注解的一些详解

 

    1>.spring注解

         @Component("user")

         相当于配置文件里的  :  <bean name="user" class="com.my.bean.User" /> -------把user对象放到容器中

     以下三个注解和@Component("user")相同作用，只是为了体现是哪个层的对象

 

          @Controller("user") // web层or控制层

        @Service("user") // service层

        @Repository("user")// dao层

   例：   -----User实体类  

          public class User {

                   private String name;

                    @Value("18") //注入值，还可以通过在setAge上面写这个注解来注入值

                   private Integer age;

                    @Autowired //自动装配，下面属性为对象，根据类型来检测容器当中所有符合这个属性类型的对象，所以在Car的实体类里要加上                     @Component("car")把Car放入容器中

                    private Car car;//car实体类

       注：如果匹配多个类型一致的对象.将无法选择具体注入哪一个对象.（即有多个car对象）

 

       1).@Autowired //自动装配，

          @Qualifier("car2")//使用Qualifier注解告诉spring容器自动装配哪个名称的对象

          private Car car;

       2).@Resource(name="car")//手动注入,指定注入哪个名称的对象

          private Car car;

 

    2>.其他注解

           Service层

                  @Service     -------默认情况下是将 UserSevice的对象放到 IOC容器里面去 ，默认的名字叫小写userService 

                  @Service(value="userService") -----代表的是我们下面这个类放到IOC容器里面的时候的名字

                  @Scope(value="singleton")------设置这个类的生成模式 是单例的 还是多例的 

                  @Lazy(value=false):--------这个表示的是是否默认延迟生成对象， 这个只是对单例有

 

                 @Repository:--将生成对象放到IOC的容器里面（用法一样）

                 @Component:--这个呢也是生成对象放到IOC容器里面（用法一样）

                 @Resource:---表示的是注入对象(必须在我们的IOC容器里面有这个对象才能进行注入)

 

这儿还未完，代码详解----************************************

 

7.AOP编程

          1>. 什么是AOP编程? 

          AOP编程叫做面向切面的编程,------就是我们在开发中 ,可以将重复的代码抽取出来 形成一个类 ,当我们的程序在运行的时候通过代理的     方式,动态的将我们公共地方的代码可以植入进去进行运行, 这个思想 就叫做 面向切面的编程

        抽取出来的这个公共的类我们以前要么叫基类 ,要么做成一个帮助类utils类；

        而现在抽取出来的这个类 在面向切面编程中叫做 切面类！

        代码被植入的地方称为切入点

        描述代码植入的地点的表达式 就称为 切入点表达式

 

        2>. AOP面向切面编程思想：

                过滤器，拦截器，动态代理   都可以体现AOP思想

                spring aop开发：

                spring封装了动态代理代码，通过配置的形式，我们就不需要手写动态代理代码（被代理对象必须实现接口），还封装了cglib代理             （不需要接口），所以封装了这两个类就可以对任何类进行代理增强。

 

       3>. AOP切入点表达式：             

              com.my.service.UserServiceImpl.save()   //  返回值任意类型，匹配得是com.my.service包下的UserServiceImpl类的空参save方法

              com.my.service.UserServiceImpl.*()    //   *()  所有空参方法

              com.my.service.*ServiceImpl.*(..)   //  *ServiceImpl.*(..)表示匹配所有以ServiceImpl结尾的类并且参数不要求的所有方法

              com.my.service..*ServiceImpl.*(..)   //  两点表示service包的子包也考虑在内

         4>.传统的AOP

 

1 @Service//注解，告诉我们属于业务层 2 public class UserService { 3     @Autowired //自动装配 4     private Aop aop=null; 5  6         @Autowired 7     private UserDao userDao=null;  8  9     public void regsiter(){10         aop.startTransaction();11         userDao.save();12         aop.endTransaction();13     }14 }

 

           5>.cglib下实现代理

 

 

1 @Component 2 public class UserServiceProxy implements MethodInterceptor{ 3     @Autowired 4     private UserService userService=null; 5     @Autowired 6     private Aop aop=null; 7      8     /** 9      * 生成对象10      * @return11      */12     public Object getObject(){13         Enhancer enhancer=new Enhancer();14         enhancer.setSuperclass(userService.getClass());15         enhancer.setCallback(this);16         return enhancer.create();17     }18     @Override19     public Object intercept(Object object, Method method, Object[] args,20             MethodProxy arg3) throws Throwable {21             //首先获取的是方法体的名字22             String methodName=method.getName();23             Object returnValue=null;24             25             if("regsiter".equals(methodName)){  //表示当前执行的是regsiter方法26                 aop.startTransaction();27                 //执行这个方法28                 returnValue=method.invoke(userService,args);29                 //植入我们的关闭事务的方法30                 aop.endTransaction();31             }else{32                 33                 returnValue=method.invoke(userService, args);34             }35             return returnValue;36     }37 38 }

 

         6>.动态实现AOP编程

1  @Test 2     public void test() throws Exception { 3         //生成一个动态代理的对象出来 4         ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("com/qf/aop_03/bean.xml"); 5         final Aop aop=context.getBean(Aop.class); 6         final UserService service=context.getBean(UserService.class); 7          8         IUserService service2=(IUserService) Proxy.newProxyInstance( 9                 UserService.class.getClassLoader(),10                 UserService.class.getInterfaces(),11                 new InvocationHandler() {12                     /**13                      * 方法执行的时候的中断的方法14                      */15                     @Override16                     public Object invoke(Object proxy, Method method, Object[] args)17                             throws Throwable {18                         //获取请求方法的名字19                         String methodName=method.getName();20                         Object returnValue=null;21                         if("regsiter".equals(methodName)){22                             //说明目前访问的是register方法23                             aop.startTransaction();24                             returnValue=method.invoke(service, args);25                             aop.endTransaction();26                         }else{27                             returnValue=method.invoke(service, args);28                         }29                         30                         return returnValue;31                     }32                 });33         34         service2.regsiter();35     }

          7>.注解下的AOP

 

                  @Component //这个表示的是当前这个类放到我们的ioc容器中去

                  @Scope("singleton") //当前这个类生成对象的时候 使用的单例

                  @Aspect //表示当前的这个类是一个切面类

       例：

                 就需要告诉Spring 我们要将程序放到哪里去

             (execution (   :  表示的是语法规则

                    *    :    表示的是返回值类型可以是任意的类型

                     com.my.aop.anotation.UserService.*  :   后面的这个*表示的是所有的方法

                    (..)  :   这个表示的是参数的数据类型

                完整组合起来就是：execution (  *  com.qf.aop.anotation.UserService.*  (..)  )

                     切入点表达式

                 @Pointcut(value="(execution (* com.qf.aop.anotation.UserService.*(..)))")

                  public void pt(){

                   }

 

                @Before("pt()"):表示的是在执行切入点方法之前调用下面的方法

 

                @After("pt()"):表示的是执行切入点表达式方法之后要执行的方法

 

                @AfterThrowing("pt()"):出现异常的时候执行的方法

 

                @AfterReturning("pt()"):返回值的时候动态植入的方法

 

                @Around("pt()"):环绕的时候执行的方法

 

 

 

            8>.配置模式下的AOP

 

1 
     
      12 
      13 
      14 15 
      16 
      17 18 
      19 
      20 21 
      22 
      
       23 
       24 25 26 
       27 
       
        28 
        29 
        30 
        31 
        32 
        33 
        34 
        35 
        36 
        37 
        38 
       39 
      40 
     

 

 

 

8.Spring提供的JdbcTemplate来实现数据库的相关操作

 

     1.Spring中配置我们的C3p0连接池

 

           1>:要使用Spring提供的 Jdbctemplate来完成数据库操作的话 首先导入包

 

                           Spring对Jdbctemplate支持的包

                           spring-jdbc-4.3.7.RELEASE.jar jdbc支持包

 

                           spring-tx-4.3.7.RELEASE.jar 事务相关的包

                           c3p0-0.9.1.2.jar C3p0连接池的相关包

 

                           mysql-connector-java-5.1.7-bin.jar 驱动程序的相关包

 

            2>:在配置文件中进行如下的配置

 

1 
      2 
     
       3 
       4 
       5 
       6 
       7 
       8 
       9 
      10 
      11 
     12 13 
     14 
     
      15 
      16 
     17 18 
     19 
     

              3>:编写增删该查的方法

 

1 public class UserDao { 2  3  4 private JdbcTemplate jdbcTemplate=null; //这个类是Spring提供的访问数据库的 5 public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { 6 this.jdbcTemplate = jdbcTemplate; 7 } 8 /** 9 * 添加数据    10 * @param user11 */12 public void save(String uName,String uPassword){13 String sql="insert into t_user(uName,upassword) values(?,?)";14 jdbcTemplate.update(sql,uName,uPassword);15 }16 /**17 * 删除数据    18 * @param user19 */20 public void delete(int uId){21 String sql="delete from t_user where uId=?";22 jdbcTemplate.update(sql,uId);23 }24 /**25 * 更新数据26 * @param user27 */28 public void update(User user){29 String sql="update t_user set uName=?,uPassword=? where uId=?";30 jdbcTemplate.update(sql,user.getuName(),user.getuPassword(),user.getuId());31 }32 /**33 * 查询数据34 * @param user35 */36 public List
     
       query(){37 String sql="select * from t_user";38 List
      
        list=jdbcTemplate.query(sql,new RowMapper
       
        (){39 @Override40 public User mapRow(ResultSet set, int arg1) throws SQLException {41 42 int uId=set.getInt("uId");43 String uName=set.getString("uName");44 String uPassword=set.getString("uPassword");45 User user=new User();46 user.setuId(uId);47 user.setuName(uName);48 user.setuPassword(uPassword);49 return user;50 }51 });52 53 return list;54 }