Spring 5笔记 - Githubissues

1、Spring概念 spring框架概述: 1、Spring是轻量级的开源的JavaEE框架 2、Spring可以解决企业应用开发的复杂性 3、Spring 有俩个核心部分：IOC和Aop (1)、IOC:控制反转把创建的对象过程交给Spring进行管理 (2)、Aop:面向切面，不修改源代码进行功能增强 4、Spring特点： (1)方便解耦，简化开发 (2)Aop编程支持 (3) 方便程序测试 (4)方便和其他框架进行整合 (5)方便进行事务操作 (6)降低API开发难度 (7) 5、使用spring版本5.x 1、下载spring5 地址:https://repo.spring.io/release/org/springframework/spring/ 2、打开idea 创建Java工程 3、导入Spring5相关的jar包 beans context core expression 4、创建普通类，在这个类创建普通方法 5、创建Spring配置文件，在配置文件配置创建的对象 '' ApplicationContext context = new ClassPathXmlApplicationContext("beanl.xml") 2、IOC容器 IOC 容器 (1)IOC底层原理 1、什么是IOC 控制反转(inversion of Control) 把对象创建和对象之间的调用过程，交给Spring管理使用IOC目的：为了耦合度降低前面练习操作的就是IOC实现 2、底层原理 (1)xml解析、工厂模式、反射 //原始方式创建对象调用方法 class UserService{ execute(){ UserDao dao = new UserDao(); dao.add(); } } class UserDao{ add(){ ...... } } 耦合度太高
解决办法：工厂模式 class UserService { execute(){ UserDao dao = UserFactory.getDao(); dao.add(); } } class UserDao{ add(){ ..... } } class UserFactory{ public static UserDao getDao(){ return new UserDao(); } } 目的：耦合度降低最低限度

ioc过程第一步 xml配置文件配置创建的对象第二步有service和dao类创建工厂类 class UserFactory{ public static UserDao getDao(){ String classValue = class属性值;//xml解析 Class clazz = Class.forName(classValue);//通过反射创建对象 return (UserDao)clazz.newInstance(); } } (2)IOC接口(beanFactory) 1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂 2、Spring提供IOC容器实现俩中方式：(俩个接口) BeanFactory ioc容器基本实现方式，是spring内部的使用接口，不提供开发人员使用加载配置文件时候不会创建对象，在获取对象(使用)才去创建对象 ApplicationContext BeanFactory接口的子接口，提供了更多更强大的功能，一般面向开发人员进行使用加载配置文件的时候就会把在配置文件对象进行创建 3、ApplicationContext 接口有实现类 ApplicationContext (interface) ConfigurableApplicationContext (interface) AbstractApplicationContext (class) AbstractRefreshableApplicationContext (class) AbstractRefreshableConfigApplicationContext (class) AbstractXmlApplicationContext (class) FileSystemXmlApplicationContext (class) 表示文件全路径 ClassPathXmlApplicationContext (class) 表示类路径 BeanFactory(interface) ConfigurableApplicationContext (3)IOC操作bean管理(基于xml) 1、什么是Bean管理(bean管理指的是俩个操作) Spring创建对象 Spring注入属性 2、Bean管理操作有俩种方式 (1)基于xml方式创建在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建在bean标签有很多属性， id 属性：唯一标识， class属性：类全路径(包类路径) name属性：和ID一样的的效果区别可以加/符号创建对象时候，默认也是执行无参数构造方法完成对象创建 (2)基于xml方式注入属性 DI：依赖注入，就是注入属性第一种方式：使用set方法注入创建类，定义属性和对应的set方法在spring配置文件配置对象创建，配置属性注入

       第二种方式：使用有参构造方法注入
        <bean id = "look" class="com.jdbc.domain.sends">
<constructor-arg name="sendName" value="段誉"></constructor-arg>
//不够准确
            <constructor-arg index="0" value="紫英"></contructor-arg>             
        </bean>
     p名称空间注入
       使用p名称空间注入，可以简化基于xml配置方式
         xmlns:p = "http://www.springframework.org/schema/p" 添加到配置中
       <bean id="main" class="com.jdbc.domain" p:sendName="九阳神功" p:userName="九阴真经"></bean>
       (3)、IOC 操作Bean管理 (xml注入其他类型属性)
     1.字面量 
        一、null值
         <property name = "sendName">
           <null/>
          </property>
        二、属性包含特殊符号
        <property name = "" >
        <!-- &lt; &gt;    CDATA  -->
           <value>
            <![CDATA[<<南京>>]]>
           </value>
        </property>
    2.注入属性-外部bean
      (1)创建俩个类Service类 和dao类
      (2)在service调用dao里面的方法
       使用原始方式  UserDao userDao = new UserDaoImpl();
                userDao.update();
      (3)在spring里面调用
        private UserDao userDao ;
        public void setUserDao(UserDao userDao){
            this.userDao = userDao;
        }
        <bean id="userService" class="com.sglb.service.UserService">
           <property name = "userDao" ref="userDaoImpl"></property>
        </bean>
        <bean id = "userDaoImpl" class= "com.dao.UserDaoImpl"></bean>
    3.注入属性-内部bean和级联赋值
     (1)一对多关系，部门和员工
      一个部门有多个员工，一个员工属于一个部门
      (2)在实体类之间表示一对多关系，员工表示
      //部门
        class Dept{
            private String dname;
            //set  get  方法
        }
        //员工
        class Emp{
         private String ename;
         private String gender;
         private Dept dept;
         //set  get 方法
        }
        内部bena
        <bean id="emp" class="com.emp" >
         <property name="ename" value="111"></property>
         <property name="gender" value="222"></property>
         <property name="dept" >
            <bean id="dept" class="com.Dept">
             <property name="dname" value="人事部"></property>
            </bean>
         </property>
        </bean>
    4.级联赋值
    (1)写法
      <bean id="emp" class="com.emp">
        <property name="ename" value="lucy"></property>
        <property name="gender" value="nv"></property>
        <property name="dept" ref="dept"></property>
      </bean>
      <bean id="dept" class="com.Dept">
        <property name="dname" value="法务部"></property>
      </bean>
    (2)
      <bean id="emp" class="com.emp">
        <property name="ename" value="lucy"></property>
        <property name="gender" value="nv"></property>
        <property name="dept" ref="dept"></property>
        <property name="dept.dname" value="技术部"></property>
      </bean>
      <bean id="dept" class="com.Dept">
        <property name="dname" value="法务部"></property>
      </bean>

(4)IOC操作bean管理(基于注解) 1、注入数组类型属性 class a{ private String[] courses; } 2、注入list集合类型属性 class a{ private List list; } 3、注入map集合类型属性 class a{ private Map<String,String> maps; private Set sets; }

java课程 adb课程 java课程 adb课程 java课程 adb课程

   4.在集合里面设置对象类型值
     <property name="coureseList">
       <list>
         <ref bean="course1"></ref>
         <ref bean="course2"></ref>
       </list>
     </property>
     <bean id="course1" class="com.coures1">
       <property name="cname" value="Spring"></property>
     </bean>
     <bean id="course2" class="com.coures1">
       <property name="cname" value="Spring2"></property>
     </bean>
   5.把集合注入部分提取出来
     (1)在spring配置文件中引入名称空间util
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd"
     (2)使用util标签完成
       <util:list id="bookList">
       <!-- 对象-->
        <ref bean=""></ref>
        <!-- 类型 -->
         <value>易经经</value>
         <value>一阳指</value>
         <value>神龙斩</value>
       </util:list>
       <bean id="book" class="com.book">
        <property name="list" ref="bookList"></property>
       </bean>
     IOC操作bean管理(FactoryBean)
     1.Spring有俩种类型bean,一种普通bean,另一种工程bean(FactoryBean).
     2.普通bean:在配置文件中定义bena类型就是返回类型
     3.工厂bean:在配置文件定义bean类型可以和返回类型不一样
      第一步创建类，让这个类座位工厂bean，实现接口FactoryBean
      第二步实现接口里面的方法，在实现的方法中定义返回的bean类型
      public class MyBean implements FactoryBean<Course>{
        public Course getObject() throws Exception{
          Course course = new Course();
          course.setCname("abc");
          return course;
        }
      }
     IOC操作bean管理(bean作用域)
     1.在Spring里面，设置创建bean实例是单实例还是多实例
     2.在Spring里面，默认情况下，bean是单实例
     3.如何设置单实例还是多实例
     (1)在spring配置文件bean标签里面有属性(scope)用于设置单实例还是多实例
     (2)scope属性值
     第一个值默认值，singleton 表示是单实例对象
     第二个值 prototype ,表示是多实例对象
     <bean id="book" class="com.book" scope="prototype">
        <property name="list" ref="bookList"></property>
     </bean>
     IOC操作Bean管理(bean生命周期)
             1.生命周期
        (1)从对象创建到对象销毁的过程
      2.bean的生命周期
        (1)通过构造器创建bean实例(无参数构造)
        (2)为bean的属性设置值和对其他bean引用(调用set方法)
        (3)调用bean的初始化的方法(需要进行配置初始化的方法)
        (4)bean可以使用了(对象获取到了)
        (5)当容器关闭时候，调用bean的销毁的方法(需要进行配置销毁的方法)
      3.bean生命周期
      <bean id="orders" class="com.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="iphone" value="手机"></property>
      </bean>
      class Orders{
        public Orders(){
          System.out.println("------无参构造初始化");
        }
        private String iphone;
        public void setIphone(String iphone){
         this.iphone = iphone;
        }
        public void initMethod(){
          System.out.println("111初始化方法");
        }
        public void destroyMethod(){
          System.out.println("222销毁");
        }
      }
      public void testBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Orders orders = context.getBean("orders",Orders.class);
        System.out.println("获得创建的对象");
        System.out.println(orders);
        ((ClassPathXmlApplicationContext)context).close();
      }
      4.bean的后置处理器，bean的生命周期有七步
       第三步之前
       (3)把bean的实例传递bean后置处理器的方法
       postProcessBeforeInitialization
       (5)把bean的实例传递bean后置处理器的方法
       postProcessAfterInitialization
      5.添加后置处理器效果
       (1)创建类，实现接口BeanPostProcessor,创建后置处理器
       <!-- 配置后置处理器-->
       <bean id="myBeanPost" class="com.MyBeanPost"></bean>
       public class BeanPost implements BeanPostProcessor{
         public Object postProcessBeforeInitialization(Object bean,String beanName)throws BeansException{
         System.out.println("之前");
         return bean;
         }
         public Object postProcessAfterInitialization(Object bean,String beanName)throws BeansException{
         System.out.println("之后");
         return bean;
         }
       }
      IOC操作Bean管理(xml自动装配)
      1.什么是自动装配
        (1)根据指定装配规则(属性名称或者属性类型)Spring自动将匹配的属性值进行注入
      2.自动装配过程
      byName根据名称注入 ,注入值bean的ID值和类属性名称一样 
      byType根据属性类型注入
       <bean id="de" class="de" autowire="byName"></bean>
       <bean id="dept" class="Dept" autowire="byType"></bean>
      IOC操作bean管理(引入外部属性文件)
       1.直接配置数据库信息
        (1)配置德鲁伊连接池
        (2)引入德鲁伊连接池依赖jar包
        复制到lib目录下添加jar包
        <bean id="dataSource" class="com.alibaba.druid.pool.DruiDataSource">
          <property name="driverClassName" value="com.mysql.jdbc.Driver"> </property>
          <property name="url" value="jdbc:mysql://localhost:3306/test"> </property>
          <property name="username" value="root"> </property>
          <property name="poassword" value="root"> </property>
        </bean>
       2.引入外部属性文件配置数据库连接池
        1创建外部属性文件，
        jdbc.properties
        prop.driverClass=com.mysql.jdbc.Driver
        prop.url=jdbc:mysql://localhost:3306/test
        prop.userName=root
        prop.password=root
        2.把外部properties属性文件引入到spring配置文件中
        引入context名称空间
        xmlns:context="http://www.springframework.org/schema/context"
        http://www.springframework.org/schema/context
        http://www.springframework.org/spring-context.xsd
       <!-- 引入外部文件 -->
         <context:property-placeholder location="classpath:jdbc.properties"/>
         <bean id="dataSource" class="com.alibaba.druid.pool.DruiDataSource">
          <property name="driverClassName" value="${prop.driverClass}"> </property>
          <property name="url" value="${prop.url}"> </property>
          <property name="username" value="${prop.userName}"> </property>
          <property name="poassword" value="${prop.password}"> </property>
        </bean>
         IOC操作bean管理(基于注解方式)
         1.什么是注解
          (1)注解是代码特殊标记, 格式:@注解名称(属性名称=属性值，属性名称=属性值..)
          (2)使用注解 注解作用在类上面 方法上面 属性上面
          (3)使用注解目的简化xml配置
         2.Spring针对bean管理创建对象提供注解
           (1)@Component
           (2)@Service
           (3)@Contorller
           (4)@Repository
            上面四个注解功能都是一样的都可以用来创建bean实例
         3.基于注解方式实现对象创建
           第一步，引入依赖 aop的包
           第二步，开启组件扫描
           1、如果要扫描多个包用,隔开
           2、扫描包上层目录
           <context:component-scan base-package="com.dao,com.service"></context:component-scan>
           3.创建类 在类上面添加注解
           //注解里面的value属性值可以省略不写
           //默认类名称 首字母小写
           @Component(value="userService") //<bean id="userService" class="..."></bean>
           4.开启组件扫描细节配置
           <context:component-scan base-package="com.Controller" use-default-filters="false">
           <!-- 设置那些内容不进行扫描 -->
           <context:include-filter type="" expression="org.springframework.stereotype.Controller"/>
           </context:component-scan>
           5.基于注解方式实现属性注入
           (1)@Autowired 根据属性类型进行自动装配
           第一步把service和dao对象创建，在service和dao类添加创建对象注解
           第二步在service注入dao对象，在service类添加dao类型属性
           (2)@Qualifier 根据属性名称进行注入。在属性上面使用注解
           这个注解的使用和上面@Autowired一起使用
           @Autowired
           @Qualifier(value="userDaoImpl")
           private UserDao userDao;
           (3)@Resource 可以根据类型注入，可以根据名称注入
           使用方式 @Resource(name="userDaoImpl")
                    private UserDao userDao;
           (4)@Value: 注入普通类型属性
           @Value(value="sdf")
           private String name;
           6.完全注解开发
            (1)创建配置类，替代xml配置文件
            @Configuration 配置注解
            @ComponentScan(basePackages="com.*")
            public class SpringConfig{}

3、AOP 1.什么是AOP？ (1)面向切面编程(方面)利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低提高程序的可重用性，同时提高了开发效率。 (2)描述：不通过修改源代码方式添加新的功能，在主干功能里面添加新的功能 (3)使用登陆例子说明AOP 用户密码==>数据库查询==>判断是否成功失败==>重新输入密码成功==>进入主页面在登陆功能基础之上添加功能权限判断原始方式：修改源代码实现 if管理员 else if普通用户不通过修改源代码方式添加新的功能，在主干功能里面添加新的功能权限判断模块 AOP(底层原理) 1.AOP底层使用动态代理 (1)有俩种情况动态代理第一种有接口的情况使用jdk动态代理 interface UserDao{ public void login(); } class UserDaoImpl implements UserDao { public void login(){ } } 创建UserDao接口实现类代理对象，增强类的方法第二种没有接口情况使用CGLB动态代理 class User{ public void add(){ ........ } } class Person extends User{ public void add(){ super.add(); //增强逻辑 } } 1 创建当前类子类的代理对象，增强类的方法 AOP(JDK动态代理) 1.使用JDK动态代理，使用proxy类里面的方法创建代理对象 Java.lang.refletct Class Proxy java.lang.Object java.lang.reflect.Proxy (1)调用newProxyInstans方法 static Object newProxyInstance(ClassLoader loader, 类<?>[] interfaces,InvocationHandler h) 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。方法有三个参数第一参数，类加载器第二参数，增强方法所在的类，这个类实现的接口，支持多个接口第三参数，实现这个接口invocationHandler,创建代理对象，写增强的部分

     2.jdk动态代理代码
     (1)创建接口，定义方法
     (2)创建接口实现类，实现方法。
     Class[] interface = (UserDao.class)
     //Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interface,
     //new InvocationHandler(){
      // public Object invoke(Object proxy,Method method,object[] args)
      // throws Throwable{
      //  return null;
      // }
     //});
     UserDaoImpl userDao = new UserDaoImpl();
     UserDao dao =(UserDao)
     Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,
     new UserDaoProxy());

     class UserDaoProxy implements InvocationHandler{
     private Object obj;
      public UserDaoProxy(Object obj){
         this.obj=obj;
      }

      public Object invoke(Object proxy,Method method,object[] args)
       throws Throwable{
          method.getName(); 
          Arrays.toString(args);
        Object res = method.invoke(obj,args);

            obj;
        return res;
       }
     }
     AOP(术语)
     1.连接点
     类里面那些方法可以被增强，这些方法被称为连接点
     class User{
       add()

       update()

       select()

       delete()
     }
     2.切入点
     实际被真正增强的方法，称为切入点
     3.通知(增强)
       (1)实际增强的逻辑部分称为通知(增强)
       (2)通知有多种类型
         前置   后置  环绕  异常  最终 finally
     4.切面
       是动作
        (1)把通知应用到切入点过程

    AOP操作(准备)
    1.Spring框架一般基于AspectJ实现AOP操作
     (1)什么是AspectJ
        AspectJ不是Spring组成部分，独立AOP框架，
        一般把Aspectj和Spring框架一起使用，进行AOP操作
    2.基于AspectJ实现AOP操作
      (1)基于xml配置文件实现
      (2)基于注解方式实现(使用)
    3.在项目工程里面引入AOP相关依赖
    4.切入点表达式
    (1)切入点表达式作用：知道对那个类里面的那个方法进行增强
    (2)语法结构
      execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]));
      com.dao.bookdao 里面的add进行增强
      execution(* com.dao.bookdao.add(..))
      对所有方法进行增强
      execution(* com.dao.bookdao.*(..))
      对所有类，类里面所有方法进行增强
      execution(* com.dao.*.*(..))
    AOP操作(AspectJ注解)
    1.创建类，在类里面定义方法
    2.创建增强类，(编写增强逻辑)
    (1)在增强类里面，创建方法，让不同方法代表不通通知类型
    public class UserProxy{
      public void before(){

      }
    }
    3.进行通知的配置
    (1)在Spring配置文件中，开启注解扫描
    (2)使用注解创建User和UserProxy对象
    (3)在增强类上面添加注解@Aspect
    (4)在Spring配置文件中开启生成代理对象
    xmlns:aop=http://www.springframework.org/schema/aop
    <context:component-scan base-package="com.aop"></context:component-scan>
    <aop:aspectJ-autoproxy></aop:aspectJ-autoproxy>
    4.配置不同类型的通知
     (1)在增强类的里面，在作为通知方法上面添加通知类注解，使用切入点表达式配置
     @Before(value="execution(* com.user.add(..))")
     public void addddd(){
     }
     @AfterReturning(value="execution(* com.user.add(..))")
     @AfterThrowing(value="execution(* com.user.add(..))")
     @Around(value="execution(* com.user.add(..))")
     @After(value="execution(* com.user.add(..))")
    5.公共切入点抽取
      相同切入点抽取
      @Pointeut(value="execution(* com.user.add(..))")
      public void pointdemo(){

      }
      @Before(value="pointdemo()")
      public void before(){
      }
    6.有多个增强类多个同一个方法进行增强，设置增强类优先级
     (1)在增强类上面添加注解@Order(数字类型值),数字类型值越小优先级越高
             @Component
     @Aspect
     @Order(1)
     public class PersonProxy{
     }
     7.完全使用注解开发
     (1)创建配置类，不需要创建xml配置文件
     @Configuration
     @ComponentScan(basePackages="com.book")
     @EnableAspectJAutoProxy(proxyTargetClass=true)
     public class ConigAop{
     }
    AOP操作(AspectJ配置文件)
     1.创建俩个类，增强类和被增强类，创建方法
     @Configuration
     @ComponentScan(basePackages="com.book")
     @EnableAspectJAutoProxy(proxyTargetClass=true)
     public class ConigAop{
     }
     2.在Spring配置文件中创建俩个类对象
     <bean id="book" class="com.Book"></bean>
     <bean id="bookProxy" class="com.BookProxy"></bean>
     3.在Spring配置文件中配置切入点
     <aop:config>
       <aop:pointcut id="" expression="execution(* com.Book.buy(..))" />
       <aop:aspect ref="bookProxy">
         <aop:before method="before" pointcut-ref="p"/>
       </aop:aspect>
     </aop:config>

4、JdbcTemplate JdbcTemplate(准备) 1.什么是jdbcTemplate (1)Spring框架对JDBC进行封装,使用jdbcTemplate方便实现对数据库操作

     2.
      (1)引入相关jar包
      mysql-connector-java-5.1.7-bin.jar
      druid.jar
      spring-orm-5.2.6.RELEASE.jar
      spring-jdbc-5.2.6.RELEASE.jar
      spring-tx-5.2.6.RELEASE.jar
      (2)在spring配置文件配置数据库连接池
      <bean id="dataSource" class="com.alibaba.druid.pool.DruiDataSource" 
      destroy-method="close">
        <property name="url" value="jdbc:mysql:///test"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      </bean>
      (3)配置jdbcTemplate对象，注入DataSource
     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.jdbcTemplate">
        <property name="dataSource" ref="dataSource" ></property>
     </bean>
      (4)创建service类，创建dao类，在dao注入
      @Autowired
      private JdbcTemplate jdbcTemplate;
      <context:component-scan base-package="com.dao"></context:component-scan>
      String sql = "insert into tb_book values(?,?,?)";
      Object[] orgs ={id,name,statuc};
      jdbcTemplate.update(String sql,id,name,statuc);
      //orgs
      sql语句  可变参数 设置sql语句值
      //Object[] o1 = {"sdfsad","12","111"};
      batchArgs.add();
      bookService.batchUpdate(batchArgs);

5、事务管理事务概念 1.什么是事务 (1)事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败 (2)典型场景，银行转账； lucy 转账100元给mary lucy 少100 mary多100 2.事务四个特性 (1)原子性 (2)一致性 (3)持久性 (4)隔离性

    事务操作(Spring事务管理介绍)
    1.事务添加到JavaEE三层结构里面Service层(业务逻辑层)

    2.在Spring进行事务管理操作
    (1)有俩种方式：编程式事务和声明式事务管理(使用)
    try{
    //开启事务
    //业务操作
     userDao.dao();
     //模拟异常
     int i = 10/0;

     user.add();
    //没有发生异常，提交事务
    }catch(Exception e){
    //出现异常，事务回滚
       System.out.println();
    }
    3.声明式事务管理
    (1)基于注解方式
    (2)基于xml配置文件方式

    4.在Spring进行声明式事务管理，底层使用AOP原理

    5.Spring事务管理API
    (1)提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类
    DataSourceTransactionManager
    HibernateTransactionManager
    JPATransactionManager
    使用<tx:annotaiton-driver transaction-manager="事务管理器"引入事务管理器
    在需要事务的类或方法上使用@transactionnal

    (2)propagation:事务传播行为
    一 多事物方法直接进行调用，这个过程中事务是如何进行管理的
     public void add(){                   public void update(){
      update();  
     }                                     }
     Spring 传播行为有7种
     事务的7大传播属性 required [ri'kwaied]   required_new  support  not_support  never mandatory nested(嵌套)
    1.mandatory：必须处于事务环境下，否则会报错
    2.nested：如果该方法已经处事务环境下，依然启动新的事务，方法在嵌套的事务里执行
    3.never：不允许调用该方法的线程处于事务环境下，如果该方法处于事务环境下，就抛出异常
    4.not_supported：如果调用该方法的线程处于在事务中，则先暂停当前事务，然后执行该方法。
    5.required：要求在事务中执行该方法,有事务，直接调用，如果没事务，启动新的事务调用
    6.required_new： 如果当前执行线程已处于事务中，就会创建一个新的事物环境，在新的事物中执行
    7.supports：如果当前执行线程已处于事务中，则使用当前事务，否则不使用事务。
    (3)ioslatlon:事务隔离级别
     一 事务有特性成为隔离性，多事务操作之间不会产生影响，不考虑隔离性产生很多问题
     二 有三个问题：脏读、不可重复读、幻读
    (4)timeout:超时时间
    事务需要在一定时间内进行提交，如果不提交就回滚
    默认-1 设置时间以秒单位进行计算
    (5)readOnly:是否只读
    读：查询操作，写：添加删除修改操作
    readOnly 默认false 表示可以查询，可以修改删除添加
                 true 只能查询
    (6)rollbackFor:回滚
    设置出现异常进行事务回滚
    (7)noRollbackFor:不回滚
    设置出现异常不进行事务回滚

    事务操作 xml声明式事务管理
    1.在Spring配置文件中进行配置
    第一步配置事务管理器
    第二步配置通知
    第三步配置切入点和切面

事务操作(完全注解) 1、创建配置类，使用配置类替代xml配置文件 @Transactional(readOnly=false,timeout=-1,propagation=Propagation.REQUIRED,isolation=Isolation.REPEATED) @Configuration @ComponentScan (basePackages="com") @EnableTransactionManagement public class TxConfig{ //创建数据库连接池 @Bean public DruidDataSource getDruidDataSource(){ DruidDataSource druidSource = new DruiDataSource(); druidSource.setDriverClassName("com.mysql.jdbc.Driver"); druidSource.setUrl("jdbc:mysql://userDB"); druidSource.setUsername("root"); druidSource.setPassword("root"); return druidSource; } //创建jdbcTemplate对象 @Bean public JdbcTemplate getJdbcTemplate(DataSource dataSource){ //到IOC容器中根据类型找到dataSource JdbcTemplate jdbcTemplate = new JdbcTemplate(); //注入dataSource jdbcTemplate.setDataSource(dataSource); return jdbcTemplate; } @Bean public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){ DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(); transactionManager.setDataSource(); return transactionManager; } } 6、Spring5新特性 1、整个Spring5框架的代码基于Java8 运行时兼容JDK9,许多不建议使用的类和方法代码库中删除 2、Spring5框架自带了通用的日志封装 (1)Spring5已经移除Log4jConfigListener,官方建议使用Log4j2 (2)Spring5框架整合Log4j2 第一步引入jar包 log4j-api-2.11.2.jar log4j-core-2.11.2.jar log4j-slf4j-impl-2.11.2.jar slf4j-api-1.7.30.jar 第二步创建log4j2.xml配置文件 logs ${LOG_HOME}/backup private static final Logger log = LoggerFactory.getLogger(UserLog.class); 3.Spring5框架核心容器支持@Nullable注解 (1)@Nullable注解可以使用在方法上面，属性上面，参数上面，表示方法返回可以为空，属性值可以为空，参数值可以为空 (2)注解用在方法上面，方法返回值可以为空 @Nullable String beanName (3)注解使用在方法参数里面，方法参数可以为空 @Nullable public static String getNull(){ } (4)注解使用在属性上面，属性值可以为空 @Nullable private String bookName; 4.Spring5核心容器支持函数式风格GenericApplicationContext @Test public void text(){ GenericApplicationContext context = new GenericApplicationContext(); context.refresh(); context.registerBean(User.class,() => new User()); //context.registerBean("user1",() => new User()); //User user = (User) context.getBean("user1"); User user = (User) context.getBean("com.User"); } 5.Spring5支持整合JUnit5 (1)整合JUnit4 第一步引入Spring相关针对测试依赖 spring-test-5.2.6.RELEASE.jar JUnit4 hamcrest-core-1.3.jar junit-4.12.jar 第二步创建测试类，使用注解方式完成 @RunWith(SpringJunit4ClassRunner.class) @ContextConfiguration("classpath:bean1.xml") public class Jtest4{ @Autowired private UserService userService; @Test public void test(){ userService.accountMoney(); } } (2)Spring5整合JUnit5 第一步引入JUnit5的jar包 Add JUnit5.jar 第二步创建测试类，使用注解完成 @ExtendWith(SpringExtension.class) @ContextConfiguration("classpath:bean1.xml") public class Jtest5{ @Autowired private UserService userService; @Test public void test(){ userService.accountMoney(); } } (3)使用一个复合注解替代上面注解完成整合 @SpringJUnitConfig(locations="classpath:bean1.xml") public class Jtest5{ @Autowired private UserService userService; @Test public void test(){ userService.accountMoney(); } } 1.SpringWebflux介绍 web WebFlux (1)是Spring5添加新的模块，用于web开发，功能和SpringMVC类似的， Webflux使用当前一种比较流程响应式编程出现的框架 (2)使用传统web框架，比如SpringMVC这些基于servlet容器，webflux是一种异步非阻塞的框架，异步非阻塞的框架在servlet3.1以后才支持核心是基于Reactor的相关API实现的 (3)解释什么是异步非阻塞异步同步非阻塞和阻塞上面都是针对对象不一样异步和同步最对调用者，调用这发送请求，如果等着对方回应之后采取做其他事情就是同步如果发送请求之后不等着对方回应就去做其他事情就是异步阻塞和非阻塞针对被调用者，被调用者受到请求之后，做完请求任务之后才出反馈就是阻塞，受到请求之后马上给出反馈然后再去做事情就是非阻塞 (4)Webflux特点第一非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程第二函数式编程，Spring5框架基于Java8.webflux使用Java8 函数式编程方式实现路由请求 (5)比较SpringMVC 第一俩个框架都可以使用注解方式，都运行在Tomcat等容器中第二SpringMVC采用命令式编程，Webflux采用异步响应式编程 2.响应式编程 (1)什么是响应式编程响应式编程是一种面向数据流和变化传播的编程范式，这意味着可以在编程语音中很方便的表达静态或动态的数据流，而相关计算模型会自动将变化的值通过数据流进行传播。电子表格程序就是响应式编程的一个例子，单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。 (2)Java8及其之前版本提供的观察者模式俩个类Observer和Observable public class ObserverDemo extends Observerble{ public static void main(String[] args){ ObserverDemo observer = new ObserverDemo(); observer.addObserver((o,arg)->{ System.out.println("发送变化"); }); observer.addObserver((o,arg)->{ System.out.println("手动被观察者通知，准备改变"); }); observer.setChanged(); //数据变化 observer.notifyObservers(); //通知 } } 3.响应式编程Java实现(Reactor实现) (1)响应式编程操作中，Reactor是满足Reactive规范框架 (2)Reactor有俩个核心类，Mono和Flux，这俩个类实现接口Publisher, 提供丰富操作符，Flux对象实现发布者，返回N个元素：Mono实现发布者，返回0或者1个元素 (3)Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号元素值，错误信号，完成信号，错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了，错误信号终止数据流同时把错误信息传递给订阅者 (4)Flux和Mono 第一步引入依赖 io.projectreactor reactor-core 3.1.5.RELEASE 第二步编程代码 //方法声明 Flux.just(1,2,3,4); Mono.just(1); //其他的方法 Integer[] array = {1,2,3,4}; Flux.fromArray(array); List list = Arrays.asList(array); Flux.fromIterable(list); Stream stream = list.stream(); Flux.fromStream(stream); (5)三种信号特点错误信号和完成信号都是终止信号，不能共存的如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流如果没有错误信号，没有完成信号，表示是无限数据流 (6)调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会出发数据流，不订阅什么都不会发生的 Flux.just(1,2,3,4).subscribe(System.out::print); Mono.just(1).subscribe(System.out::print); (7)操作符对数据流进行一道道操作，成为操作符，比如工厂流水线第一 map 元素映射为新元素第二 flatMap 元素映射为流把每个元素转换流，把转换之后多个流合并大的流 4.SpringWebflux执行流程和核心API SpringWebflux基于Reactor，默认容器是netty netty是高性能NIO框架，异步非阻塞的框架的框架 (1)Netty BIO NIO (2)SpringWebflux执行过程和SpringMVC相似的 SpringWebflux核心控制器DispatchHandler 实现接口WebHandler 接口WebHandler有一个方法放Http请求响应信息根据请求地址获取对应mapping 调用具体的业务方法处理返回结果 (3)SpringWebflux里面DispatcherHandler负责请求的处理 HandlerMapping 请求查询到处理的方法 HandlerAdapter 真正负责请求处理 HandlerResultHandler 响应结果处理 (4)SpringWebflux实现函数式编程，俩个接口：RouterFunction(路由处理)和HandlerFunction(处理函数) 5.SpringWebflux(基于注解编程模型) SpringWebflux实现方式有俩种：注解编程模型和函数式编程模型使用注解编程模型方式，和之前SpringMVC使用相似的，只需要把相关依赖配置到项目中，Springboot自动配置相关运行容器，默认情况下使用netty服务器第一步创建SpringBoot工程，引入webflux依赖 org.springframework.boot spring-boot-starter-webflux 第二步配置启动端口 server.port = 80; 第三步创建包和相关类 com.webflux.entity / service /controller public Mono getUserId(); Mono.justOrEmpty(); public Flux getAllUser(); 编写service层 @Repository 说明 SpringMVC方式实现，同步阻塞的方式，基于SpringMVC +Servlet+Tomcat SpringWebflux方式实现，异步非阻塞方式，基于SpringWebflux +Reactor+Netty 6.SpringWebflux(基于函数式编程模型) (1)在使用函数式编程模型操作得时候，需要自己初始化服务器 (2)基于函数式编程模型时候，有俩个核心接口：RouterFunction(实现路由功能，请求转发给对应的handler) 和HandlerFunction(处理请求生成响应的函数)，核心任务定义俩个函数式接口的实现并且启动需要的服务器 (3)SpringWebflux请求和响应不再是ServletRequest和ServletResponse 而是ServerRequest和ServerResponse 第一步把注解编程模型工程复制一份第二步创建Handler(具体实现方法) public class UserHandler{ private final UserService userService; public UserHandler(UserService userService){ this.userService = userService; } public Mono getUserId (ServerRequest req){ int user =Integer.valueOf(req.pathVariable("id")); Mono notFound = ServerResponse.notFound.build(); Mono userMono = this.userService.getUserId(user); return userMono.flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON) .body(fromObject(person)) .switchIfEmpty(notFound)); } public Mono getAllUser(ServerRequest req){ Flux users = this.userService.getAllUser(); return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON) .body(users,User.class); } public Mono saveUser(ServerRequest req){ Mono userMono = request.bodyToMono(User.class); return ServerResponse.ok().build(this.userService.saveUserInfo(userMono)); } } 第三步初始化服务器编写Router 1创建路由的方法 public class Server{ public RouterFunction routingFunction(){ UserService userService = new UserServiceImpl(); UserHandler handler = new UserHandler(userService); return RouterFunctions.route( GET("/users/{id}").and(accept(APPLICATION_JSON)) ,handler::getUserId). addRoute(GET("/users").and(accept(APPLICATION_JSON)),handler::getAllUsers); } } 2创建服务器完成适配 public void createReactorServer(){ //路由和handler适配 RouterFunction route = routingFunction(); HttpHandler httpHandler = toHttpHandler(route); ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler); //创建服务器 HttpServer httpServer = HttpServer.create(); httpServer.handler(adapter).bindNow(); } 调用 public static void main(String[] args)throws Exception{ Server server = new Server(); server.createReactorServer(); } (4)使用WebClient调用 public class Client{ public static void main(String[] args)throws Exception{ //调用服务器地址 WebClient webClient = WebClient.create("http://127.0.0.1:5794"); String id = "2"; User userResult = webClient.get().uri("/users/{id}",id) .accept(MediaType.APPLICATION_JSON) .retrieve().bodyToMono(User.class) .block(); System.out.println(userResult.getName()); Flux result = webClient.get().uri("") .accept(MediaType.APPLICATION_JSON) .retrieve().bodyToFlux(User.class); result.map(stu -> stu.getName()) .buffer().doOnNext(System.out::prinln).blockFirst(); } }

tianyou168 / issue

Spring 5笔记 #1