Spring-1-（简介及HelloWord）

时间 2019-11-17

标签 spring 简介 helloword 栏目 Spring 繁體版

原文原文链接

一：Spring简介java

　　Spring 框架宗旨:不从新发明技术,让原有技术使用起来更加方便.mysql

　　Spring核心功能：程序员

　　　　1.AOP：面向切面编程web

　　　　2.Ioc/Di:控制反转/依赖注入spring

　　　　3.声明式事务sql

　　Spring框架RunTime（运行时环境）数据库

　　　　Spring中的容器（Container）：express

　　　　　　 Spring 框架中重要概念编程

　　　　　容器(Container): Spring 看成一个大容器.数组

　　　　　 BeanFactory 接口.老版本.

　　　　　 ApplicationContext 接口,新版本，是 BeanFactory 子接口

　　　　　　BeanFactory 的功能在 ApplicationContext 中都有

　　　　Spring拆分jar包：

　　　　　　Spring3 开始把 Spring 框架的功能拆分红多个 jar. 7.1 Spring2 及之前就一个 jar（优势：可根据不一样的需求导入不一样的jar，而不需将Spring中的60多个jar都加载进去）

　　　　解析框架：

　　　　　　test: spring 提供测试功能

　　　　　　Core Container:核心容器.Spring 启动最基本的条件. （将spring跑起来至少有这些东西）

　　　　　　　　Beans : Spring 负责建立类对象并管理对象

　　　　　　　　Core: 核心类（类库）

　　　　　　　　Context: 上下文参数.获取外部资源或这管理注解等

　　　　　　　　SpEl: expression.jar

　　　　　　AOP: 实现 aop 功能须要依赖

　　　　　　Aspects: 切面 AOP 依赖的包

　　　　　　Data Access/Integration : spring 封装数据访问层相关内容

　　　　　 JDBC : Spring 对 JDBC 封装后的代码. 5.5.2 ORM: 封装了持久层框架的代码.例如 Hibernate

　　　　　 Transactions:对应 spring-tx.jar,声明式事务使用. 5.6 WEB:须要 spring 完成 web 相关功能时须要. 5.6.1 例如:由 tomcat 加载 spring 配置文件时须要有 spring-web包

　　　注意：Spring运行并不依赖与Web容器（tomcat等等），jar包依旧能够运行，可是spring提供了web的jar包，因此也可使用web容器来运行

二：核心功能

　　一）IoC

　　1 中文名称:控制反转

　　2.英文名称:(Inversion of Control)

　　3.IoC 是什么?
　　　　3.1 IoC 完成的事情原先由程序员主动经过 new 实例化对象事情,转交给 Spring 负责.

　　　　3.2 控制反转中控制的是谁:

　　　　　　控制类的对象.

　　　　3.3 控制反转中反转指的是：

　　　　　　原来有程序员管理的类的对象转交给 Spring 负责管理.

　　　　3.4 IoC 最大的做用:解耦.

　　　　　　3.4.1 程序员不须要管理对象.解除了对象管理和程序员之间的耦合.

//以往咱们须要本身手动的建立对象，并进行使用
 User user = new User();
 String address = user.getAddress();
 

//如今咱们只须要将spring容器中的对象拿出来使用就行了       
 @Autowired
 User user;
 String address1 = user.getAddress();

　　IoC容器有两种：
　　　　BeanFactory：
　　　　　　简介：
　　　　　　　　基础类型的IoC容器，由org.springframework.beans.factory.BeanFactory接口定义，并提供了完整的IoC服务支持；
　　　　　　　　BeanFactory是一个管理Bean的工程，负责初始化各类Bean并调用他们的生命周期方法。
　　　　　　实现：
　　　　　　　　org.springframework.beans.factory.xml.XmlBeanFactory,根据xml配置文件中的定义来装配Bean

　　　　　ApplicationContext：（也就是咱们配置的ApplicationContext.xml）
　　　　　　简介：
　　　　　　　　是BeanFactory的子接口，也被称为应用上下文，由org.springframework.context.ApplicationContext提供，
　　　　　　　　他提供BeanFactory全部的功能，而且增强了BeanFactory的功能，体如今Context包使用分层和有继承关系的上下文类：
　　　　　　　　　　1.MessageSource，提供对i18n消息的访问；
　　　　　　　　　　2.资源访问，例如URL和文件
　　　　　　　　　　3.事件传递给实现了ApplicationListener接口的Bean；
　　　　　　　　　　4.载入多个有集成关系的上下文类，使每个上下文类都专一于一个特定的层次，

　　　　　　　　几乎全部的场合都是用ApplicationContext而非底层的BeanFactory
　　　　　　　　建立ApplicationContext接口实例(建立IoC容器)：
　　　　　　　　　　方式一：(从类路径中的xml文件载入上下文定义信息)
　　　　　　　　　　　　ApplicatonContext applicationcontext=new ClassPathXmlApplicationContext（"applicationContext.xml"）
　　　　　　　　　　方式二：（从文件路径中的xml文件载入上下文定义信息）
　　　　　　　　　　　　ApplicatonContext applicationcontext=new FileSystemXmlApplicationContext("F:\\workspace\\applicationContext.xml")

　　这里建立的是一个web工程可是使用的main方法执行也能够放进tomcat中运行）

　　所依赖的jar包（核心包以外还要加一个日志包commons-logging.jar）：

<bean class="com.xpl.model.User" id="user">

public class Text {
    public static void main(String[] args) {
//        将applicationContext加载进去，初始化spring容器
//        spring初始化的时候就会将容器中的全部组件初始化，这个时候对象已将建立
//        他是经过类的无参构造进行初始化的
        ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//        获取spring容器中的组件
//        方式有三种：
//            方式一：经过id获取，可是要强转
//        User user = (User) cxt.getBean("user");
//            方式二：经过id和类获取
        User user = cxt.getBean("user4", User.class);
        System.out.println(user);
//            方式三：经过class类获取，有个缺陷，加入spring中使用这个类建立了多个实例，就会冲突，找不到
        User bean = cxt.getBean(User.class);
        String[] beanDefinitionNames = cxt.getBeanDefinitionNames();
//        能够看到spring容器中全部的组件名字
        for(int i=0;i<beanDefinitionNames.length;i++){
            System.out.println(beanDefinitionNames[i]);
        }
    }
}

　　Spring建立实例的三种方式：

　　1).构造器建立

　　　　1.1.无参构造器（默认）

　　　　1.2.有参构造

　　　　　　　　　　具体使用参照下边的代码注释

　　2).实例工厂

　　3).静态工厂.

<!--经过构造器注入bean-->
    <bean class="com.xpl.model.User" id="user">
        <constructor-arg index="0" value="张三"/>
        <constructor-arg index="1" value="27"/>
    </bean>
    <!--结果-->
    <!--有参构造String name, int age-->
    <!--User{name='张三', age=27}-->
    <bean class="com.xpl.model.User" id="user1">
        <constructor-arg name="name" value="李四"/>
        <constructor-arg name="age" value="27"/>
    </bean>
    <!--结果-->
    <!--有参构造int age,String name-->
    <!--User{name='李四', age=27}-->
    <!--发现：走的是后边（有两个有参构造，第二个有参构造）-->
    <!--是由于经过有参构造，name属性赋值时候，执行参数相同的构造器的最后一个）-->
    <!--这个时候就须要使用参数中的index或者type来精准定位-->
    <!--注意不须要全都写，配合使用只要能定位到某个构造器就能够-->
    <bean class="com.xpl.model.User" id="user2">
        <constructor-arg name="name" index="0" value="王五"/>
        <constructor-arg name="age" value="27"/>
    </bean>
    <!--结果-->
    <!--有参构造String name, int age-->
    <!--User{name='王五', age=27}-->

<!--实例工厂建立-->
    <!--实例工厂须要实例化，因此先注入进来-->
    <bean class="com.xpl.model.UserFactory" id="userFactory"/>
    <!--指定实例工厂是哪个，在指定工厂方法是哪个-->
    <bean factory-bean="userFactory" factory-method="creatPeople" id="user3"/>


<!--静态工厂建立-->
    <bean class="com.xpl.model.UserStaticFactory" factory-method="creatPeople" id="user4"/>

　　对象属性赋值：

　　 1).构造方法注入（上边已经演示过了参考）

　　 2).经过set方法注入

　　　　　　　基本数据类型：

　　　　　　　复杂数据类型：

<bean class="com.xpl.model.User" id="user">
        <!--基本数据类型-->
        <property name="name" value="赵六"/>
        <!--数组-->
        <property name="arr">
            <array>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </array>
        </property>
        <!--若是list中只有一个值也能够这样写-->
        <!--<property name="arr" value="1"/>-->
        <!--引用数据类型，引用上边的cat-->
        <property name="cat" ref="cat"/>
        <!--list-->
        <property name="list">
            <list>
                <value>5</value>
                <value>6</value>
                <value>7</value>
            </list>
        </property>
        <!--若是list中只有一个值也能够这样写-->
        <!--<property name="list" value="1"/>-->
        <!--map-->
        <property name="map">
            <map>
                <entry key="1" value="2"/>
                <entry key="2" value="2"/>
                <entry key="3" value="2"/>
            </map>
        </property>
        <property name="set">
            <set>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </set>
        </property>
        <property name="properties">
            <props>
                <prop key="1">1</prop>
                <prop key="2">2</prop>
                <prop key="3">3</prop>
            </props>
        </property>
   </bean>

　　二）DI

　　1. DI:中文名称:依赖注入

　　 2. 英文名称((Dependency Injection)

　　 3. DI 是什么?

　　　　　　3.1 DI 和 IoC 是同样的

　　　　　　3.2 当一个类(A)中须要依赖另外一个类的对象时,把 B 赋值给 A 的过程就叫作依赖注入.（注入：就是给spring容器中的bean赋值的过程；当Bean中的某个属性是另外一个Bean时，把这个Bean以属性的方式注

　　　　　　入进去就是依赖注入，广义上描述他就是Aop，狭义上描述就是将一个Bean做为了另一个Bean的属性）

//首先有一个bean，这个Bean就是下边Bean的一个属性   
　　<bean class="com.xpl.model.User" id="user">     
   　　<property name="cat" ref="cat"/>
   </bean>    
    <bean class="com.xpl.model.Cat" id="cat">
        //这个Bean中的属性是一个Bean
       <property name="name" value="小白猫"/>
   </bean>

public class User {
   　　 private Cat cat;
    　　private Properties properties;
　　}

　　public class Cat {
 　　   private String name;
　　}

　　三）AOP　　

　　 1.AOP:中文名称面向切面编程

　　 2.英文名称:(Aspect Oriented Programming)

　　 3.正常程序执行流程都是纵向执行流程

　　　　　　3.1 又叫面向切面编程,在原有纵向执行流程中添加横切面

　　　　　　3.2 不须要修改原有程序代码

　　　　　　　　3.2.1 高扩展性

　　　　　　　　3.2.2 原有功能至关于释放了部分逻辑.让职责更加明确.

　　概念：（原理：动态代理）

　　　　在程序原有纵向执行流程中,针对某一个或某一些方法添加通知,造成横切面过程就叫作面向切面编程.

　　　　主要体如今事务处理，日志管理，权限控制，异常处理等方面，提升代码的可维护性。

　　　　原有功能: 链接点, pointcut（在某个方法前织入，这个方法就叫链接点）

　　　　增长的部分叫作通知（加强Advice）

　　　　　　前置通知: 在切点以前执行的功能. before advice

　　　　　　后置通知: 在切点以后执行的功能,after advice

　　　　　　异常通知.throws advice

　　　　　　环绕通知：

　　　　全部切点+通知叫作切面.

　　　　织入: 把切面嵌入到原有功能的过程叫作织入

　　　　重要：spring声明式事务是基于aop实现的，事务通常是用在service上的，有了事务service中一旦出现异常就会回滚，

　　　　　　 因此不建议在service中使用try-catch，由于使用try-catch以后aop就捕获不到异常，声明式事务就失效了

　　java原生动态代理：

public interface Calculate {  
    public int add(int a,int b);
    public int min(int a,int b);
}

public class Calculateimpl implements Calculate {
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public int min(int a, int b) {
        return a-b;
    }
}

public class ProxyFactory {
    //建立代理对象
    public Object createMyCalculate(Object obj){
        //Proxy是java反射中的一个类  obj.getClass().getClassLoader()获取类加载器  实现的接口
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            //代理的那个对象（传入的） 要处理的方法  传入的参数
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("star");
                //调用方法并执行
                Object invoke = method.invoke(obj, args);
                System.out.println("end");
                return invoke;
            }
        });
    }
}

public class Text {
    public static void main(String[] args) {
        ProxyFactory proxyFactory=new ProxyFactory();
        Calculateimpl calculateimpl=new Calculateimpl();
        Calculate calculate=(Calculate)proxyFactory.createMyCalculate(calculateimpl));
        calculate.add(1,3);
    }
}

　　Spring中aop实现：

　　XML方式配置：

/**
 * 定义advice
 */
public class Advice {
    public void before(){
        System.out.println("前");
    }
    public void mythrow(Exception e){
//        还须要配置xml才能够打印出异常信息
        System.out.println("异常"+e.getMessage());
    }
    public void  after(){
        System.out.println("后");
    }
    public void aftering(){
        System.out.println("aftering");
    }
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("执行环绕通知");
        System.out.println("环绕-前置");
//        返回值
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println(proceed);
        System.out.println("环绕-后置");
        return proceed;
    }
}

public class Demo {
    public int min(int i,int j){
        return i+j;
    }
}

public class Text {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
        Demo demo = cxt.getBean("demo", Demo.class);
        demo.min(1,5);
    }
}

<!--将要被加强的对象注入进来-->
<bean class="com.xpl.test.Demo" id="demo"/>
<!--将advice注入进来-->
<bean class="com.xpl.advice.Advice" id="advice"/>
<aop:config>
    <!--定义切点：就是要在哪一个方法上加强-->
    <aop:pointcut id="min" expression="execution(int com.xpl.test.Demo.min(int ,int ))"/>
    <!--定义切面：切点+加强-->

    <!--引用的就是上边注入进来的加强Bean-->
    <aop:aspect ref="advice">
        
        <!--这几个加强是有顺序的特别是异常aftering和after-->
        <!--通知类型    加强方法名（加强类中的）    被加强的方法（上边定义的切点）-->
        
        <!--after和after-returning的区别：-->
                <!--after不管是否抛出异常都会执行-->
                <!--after-returning必须正确执行才会执行-->
        <aop:after method="after" pointcut-ref="min"/>
        <aop:after-returning method="aftering" pointcut-ref="min"/>
        <aop:after method="before" pointcut-ref="min"/>
        <!--必须和加强类中异常方法中参数的异常名相同-->
        <aop:after-throwing method="mythrow" pointcut-ref="min" throwing="e"/>
       
        <aop:around method="around" pointcut-ref="min"/>
    </aop:aspect>
</aop:config>

　　　　通配符*

　　　　在定义切点的时候可使用*通配符精肯定位切点

　　　　他支持一级包名

<aop:pointcut id="min" expression="execution(int com.xpl.test.Demo.min(int ,int ))"/>

表示com包下的全部包中的全部方法
<aop:pointcut id="min" expression="execution(* com.*.*.*.*(* ,* ))"/>

　　四）自动注入

　　前提：Spring全局配置文件中

　　　看代码理解：

　　　　两个类A和B须要交给Spring管理

　　　　B中有个属性是对象A

　　　　非自动注入：本身写本身的property给属性赋值，或使用ref

　　　　自动注入：在bean标签上使用autowire属性

　　 原理：Byname去判断我须要注入的属性名在spring容器中是否存在id名称同样的，存在就直接注入给他，

　　　　　 Bytype是去找class

　　　　　 Constructor：须要实体类中有有参构造方法，而且参数名称要和xml中的name同样

public class B {
    private String name;
    private A a;

public class A {
    private String name;

没有自动注入
<bean class="com.xpl.model.A" id="a">
       <property name="name" value="aaa"/>
</bean>-->
<bean class="com.xpl.model.B" id="b">
        <property name="name" value="bbbbb"/>
        <property name="A" ref="a"/>
</bean>

自动注入
<bean class="com.xpl.model.A" id="a">
        <property name="name" value="aaa"/>
</bean>
<bean class="com.xpl.model.B" id="b" autowire="byName">
        <property name="name" value="bbbbb"/>
</bean>

　　　　也能够配置为全局的

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">

五：加载配置文件

　　注意：经过配置文件健在内容的时候要注意使用下边高亮部分

　　缘由是：实例化前后顺序形成的，以避免在实例化完成以后加载配置文件就加载不进去了

db.driver=com.mysql.jdbc.Driver
db.username=root
db.password=root
db.url=jdbc:mysql:///test?useUnicode=true&characterEncoding=UTF-8

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:db.properties"/>
    <!--配置数据源-->
    <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
        <property name="driverClassName" value="${db.driver}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
        <property name="url" value="${db.url}"/>
    </bean>
    <!--建立sqlSessionFactory-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="factory">
        <!--建立sqlSession须要有数据库链接，na那么就引用上边的数据源-->
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.xpl.model"/>
    </bean>
　　//扫描配置mapper.xml文件
　　 <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
　　　　 <property name="dataSource" ref="dataSource"/>
　　　　 <property name="typeAliasesPackage" value="com.xpl.model"/>
　　　　 <property name="mapperLocations">
　　　　　　<list>
　　　　　　　　<value>classpath*:com/xpl/mapper/*.xml</value>
　　　　　　</list>
　　　　</property>
　　　</bean>
    <!--扫描器，加载mapper接口-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
　　　　　　//配置这一句就能够mapper接口和mapper.xml不写在一个文件夹了
        <property name="basePackage" value="com.xpl.mapper"/>
        <property name="sqlSessionFactoryBeanName" value="factory"/>
        <!--<property name="sqlSessionFactory" ref="factory"/>-->
    </bean>
</beans>

六：从配置文件中取值

people.name=xupeilei

两种方式，将bean交给Spring容器！！！这是关键，要想去spring容器中的全局的值，就必定要把这个Bean交给Spring管理！！！！！
方式一：直接配置进去

<bean class="com.xpl.model.People" id="people"/>

方式二：经过包扫描

<context:component-scan base-package="com.xpl.model"/>

public class People {
　　name这个属性名和取值时的name名没有必然关系，能够不同
    @Value("${people.name}")
    private String name;

七：Scope属性

　　默认单例

八：声明式事务

　　1.编程式事务:

　　　　1.1 由程序员编程事务控制代码. 1.2 OpenSessionInView 编程式事务

　　2.声明式事务:

　　　　2.1 事务控制代码已经由 spring 写好.程序员只须要声明出哪些方法须要进行事务控制和如何进行事务控制.

　　3.声明式事务都是针对于 Service 类下方法的.

　　4.事务管理器基于通知(advice)的.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
　　　　http://www.springframework.org/schema/beans/spring-beans.xsd 
　　　　http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd 
　　　　http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd 
　　　　http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
      
    　　 　　　　　　　　　　　　　　<!--配置数据库连接-->
        <!--引入数据库链接信息-->
    <context:property-placeholder location="classpath:db.properties"/>
        <!--配置数据库里链接池-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    </bean>
　　　　　　　　　　　　　　　　　　　<!--配置mybatis-->
    <!--配置mapper-->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.xpl.model"/>
        <property name="mapperLocations">
            <list>
                <value>classpath*:com/xpl/mapper/*.xml</value>
            </list>
        </property>
    </bean>
    <!--自动获取getXXX(mapper.xlass)-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--获取那个接口 value就是上边配的SqlSessionFactoryBean-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--接口所在的文件夹 这里配置完了就不须要将接口和mapper文件放一个文件夹了-->
        <property name="basePackage" value="com.xpl.mappering"/>
    </bean>

    　　　　　　　　　　　　　　　　　　<!--配置事务-->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
            <tx:method name="add*"/>
            <tx:method name="upd*"/>
            <tx:method name="del*"/>
            <tx:method name="sel*"/>
　　　　　　　<tx:method name="*" read-only="true"/>　
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="pc1" expression="execution(* com.xpl.service.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pc1"/>
    </aop:config>
</beans>

九：事务传播行为

<tx:method name="add*" read-only="" propagation=""/>

　　readonly=”boolean” 是不是只读事务.

　　　　1 若是为 true,告诉数据库此事务为只读事务.数据化优化,会对性能有必定提高,因此只要是查询的方法,建议使用此数据.

　　　　2 若是为 false(默认值),事务须要提交的事务.建议新增,删除,修改.

　　propagation 控制事务传播行为.

　　　　1当一个具备事务控制的方法被另外一个有事务控制的方法调用后,须要如何管理事务(新建事务?在事务中执行?把事务挂起?报异常?)

　　　　　　REQUIRED (默认值): 若是当前有事务,就在事务中执行,若是当前没有事务,新建一个事务.

　　　　　　SUPPORTS:若是当前有事务就在事务中执行,若是当前没有事务,就在非事务状态下执行.

　　　　　　MANDATORY:必须在事务内部执行,若是当前有事务,就在事务中执行,若是没有事务,报错.

　　　　　　REQUIRES_NEW:必须在事务中执行,若是当前没有事务,新建事务,若是当前有事务,把当前事务挂起.

　　　　　　NOT_SUPPORTED:必须在非事务下执行,若是当前没有事务,正常执行,若是当前有事务,把当前事务挂起.

　　　　　　NEVER:必须在非事务状态下执行,若是当前没有事务,正常执行, 若是当前有事务,报错.

　　　　　　NESTED:必须在事务状态下执行.若是没有事务,新建事务,常执行,若是当前有事务,把当前事务挂起.

十：事务隔离级别　

<tx:method name="add*" isolation="DEFAULT"/>

　　　　脏读:

　　　　　　一个事务(A)读取到另外一个事务(B)中未提交的数据,另外一个事务中数据可能进行了改变,此时 A事务读取的数据可能和数据库中数据是不一致的,此时认为数据是脏数据,读取脏数据过程叫作脏读

　　　　　　解释：A从数据库读出一条数据（aaa），并修改成（bbb）没有提交只是flush到内存中，这时B读到了内存中的数据（bbb），可是数据库中数据依旧是（aaa），B读到的就是脏数据

. 　　　 不可重复读:

　　　　　　主要针对的是某行数据.(或行中某列)

　　　　　　主要针对的操做是修改操做.

　　　　　　两次读取在同一个事务内

　　　　　　当事务 A 第一次读取事务后,事务 B 对事务 A 读取的淑君进行修改,事务 A 中再次读取的数据和以前读取的数据不一致,过程不可重复读.

　　　　　　解释：张三盘点了仓库现存50吨大豆，而后他准备卖给特朗普，这时他老婆在他不知道的状况卖给了金三胖，张三合同签回来准备发货发现大豆没有了

　　　　幻读:

　　　　　　主要针对的操做是新增或删除

　　　　　　两次事务的结果.

　　　　　　事务 A 按照特定条件查询出结果,事务 B 新增了一条符合条件的数据.事务 A 中查询的数据和数据库中的数据不一致的,事务 A 好像出现了幻觉,这种状况称为幻读.

　　isolation=”” 事务隔离级别在多线程或并发访问下如何保证访问到的数据具备完整性的.

　　　　DEFAULT:

　　　　　　默认值,由底层数据库自动判断应该使用什么隔离界别

　　　　READ_UNCOMMITTED: 能够读取未提交数据,可能出现脏读,不重复读,幻读.

　　　　　　效率最高.

　　　　READ_COMMITTED:只能读取其余事务已提交数据.能够防止脏读,可能出现不可重复读和幻读.

　　　　REPEATABLE_READ: 读取的数据被添加锁,防止其余事务修改此数据,能够防止不可重复读.脏读,可能出现幻读.

　　　　SERIALIZABLE: 排队操做,对整个表添加锁.一个事务在操做数据时,另外一个事务等待事务操做完成后才能操做这个表.

　　　　　　最安全的

　　　　　　效率最低的.

十一：事务回滚

<tx:method name="add*"rollback-for="" no-rollback-for=""/>

　　　rollback-for=”异常类型全限定路径”

　　　　　　当出现什么异常时须要进行回滚

　　　　　　建议:给定该属性值.

　　　　　　　　手动抛异常必定要给该属性值.

　　　no-rollback-for=””

　　　　　　当出现什么异常时不滚回事务.

十二：注解

1. @Component 建立类对象,至关于配置<bean/>
2. @Service 与@Component 功能相同.

　　2.1 写在 ServiceImpl 类上.

3. @Repository 与@Component 功能相同.

　　3.1 写在数据访问层类上.

4. @Controller 与@Component 功能相同.

　　4.1 写在控制器类上.

5. @Resource(不须要写对象的 get/set)（其实至关于对自动注入的补充：由于使用注解的方式auto就不生效了，可是咱们还要在类中放入属性，就将这个类放进去）
　　5.1 java 中的注解
　　5.2 默认按照 byName 注入,若是没有名称对象,按照 byType 注入
　　　　5.2.1 建议把对象名称和 spring 容器中对象名相同
6. @Autowired(不须要写对象的 get/set)
　　6.1 spring 的注解
　　6.2 默认按照 byType 注入.

7. @Value() 获取 properties 文件中内容
8. @Pointcut() 定义切点
9. @Aspect() 定义切面类
10. @Before() 前置通知
11. @After 后置通知
12. @AfterReturning 后置通知,必须切点正确执行
13. @AfterThrowing 异常通知
14. @Arround 环绕通知

十三：java配置类

　　能够不使用applicationContext.xml来配置属性而是使用一个java类来替代

　　@Configuration

　　@Componentscan:默认扫描当前包及子包的子包。。

　　@Componentscan（basePackages=“com.xpl.model”）设置扫描哪个包

　　@Bean

十四：多数据源

1. Spring1：Spring简介、环境搭建、源码下载及导入MyEclipse
2. Spring1
3. spring1
4. mybatis-spring1
5. Spring1.基础知识
6. iOS基础篇之——helloword工程搭建及基本数据类型简介
7. helloword
8. HelloWord
9. JSF HelloWord
10. Hive-HelloWord
更多相关文章...
• Scala 简介 - Scala教程
• AJAX 简介 - PHP教程
• Github 简明教程
• Flink 数据传输及反压详解