Spring基础-入门

一、spring简介

1、Spring是一个一站式轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

​ (1)、非侵入式编程（不自己new对象 不继承）

​ (2)、JavaEE的三层开发

2、原则：不重新发明轮子

二、spring IOC

1、控制反转也称为依赖注入(DI)，是面向对象编程中的一种设计理念，用来降低程序代码之间的耦合度。（new对象的主动权让给spring）

2、bean元素

1、bean:Spring IoC容器管理一个或多个bean。用来实例对象。

2、id属性是标识单个bean定义的字符串。

class属性定义Bean的类型，并使用完全限定的类名。

设值注入：

    
<bean id="UserBizImpl" class="biz.impl.UserBizImpl">
        <property name="userMapper" ref="UserMapper">property>
    bean>

     <bean id="userId" class="pojo.User">
            <property name="id" value="1">property>
        bean>

使用构造函数赋值：

 <bean id="userIdCon" class="pojo.User">
        <constructor-arg>
            <value>12value>
        constructor-arg>
        
    bean>

p命名赋值：

（1）导入命名空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

（2）赋值

<bean id="userIdP" class="pojo.User" p:id="13" p:userName="p命名">bean>

3、注入特殊符号：

使用标记

3、实例

（1）创建项目,且导入spring的jar包

​ commons-logging-1.2.jar

​ spring-beans-3.2.13.release.jar

​ spring-context-3.2.13.release.jar

​ spring-core-3.2.13.release.jar

​ spring-expression-3.2.13.release.jar

（2）创建接口和实现类

（3） 在resouces目录下创建spring的核心配置文件spring-config.xml，配置bean。

<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="..." class="...">   
        
    bean>

    <bean id="..." class="...">
        
    bean>

    

beans>

（4）测试

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
HelloSpring hs=(HelloSpring)context.getBean("bean元素里的id");

4、使用到的对象

BeanFactory：bean工厂，上产任意bean。

ApplicationContext：所有配置对象的主接口

ClassPathXmlApplicationContext：加载类路径下的配置文件

FileSystemXmlApplicationContext：加载文件系统下的配置文件

三、spring AOP

1、AOP：面向切面编程：在不改变原程序的基础上为代码段增加新的功能。

2、AOP 当中的概念：

(1)、Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
(2)、Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
(3)、Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
(4)、Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
(5)、Target（目标对象）：织入 Advice 的目标对象.。
(6)、Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程。

3、增强处理类型

1. 前置增强:在我们执行目标方法之前运行
2. 后置增强:在我们目标方法运行结束之后 ,不管有没有异常
3. 异常增强:在我们的目标方法出现异常后运行
4. 环绕增强:动态代理, 需要手动执行joinPoint.procced()(其实就是执行我们的目标方法执行之前相当于前置通知, 执行之后就相当于我们后置通知

4、实例

(1)、导入aop的jar包

aopalliance-1.0.jar

aspectjwever-1.8.9.jar

spring-aop-3.2.13.release.jar

(2)、配置文件中bean实例化

    <bean id="UserMapper" class="mapper.impl.UserMapperImpl">bean>

    <bean id="UserBizImpl" class="biz.impl.UserBizImpl">
        <property name="userMapper" ref="UserMapper">property>
    bean>

    <bean id="UserAction" class="action.UserAction">
        <property name="userBiz" ref="UserBizImpl">property>
    bean>

(3)、再编写增强类

public class TestLogger {
    private Logger log=Logger.getLogger(TestLogger.class);

    public void before(JoinPoint jp){
        log.info("进入！调用"+jp.getTarget()+"的"+jp.getSignature());
    }
    public void after(JoinPoint jp){
        log.info("退出！调用"+jp.getTarget()+"的"+jp.getSignature());
    }
    public void before1(JoinPoint jp){
        log.info("进入增加！调用"+jp.getTarget()+"的"+jp.getSignature());
    }
    public void after1(JoinPoint jp,Object rst){
        log.info("退出增加！调用"+jp.getTarget()+"的"+jp.getSignature());
    }

    public void afterEx(JoinPoint jp,RuntimeException e){
        log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"异常"+e);
    }

    public Object around(ProceedingJoinPoint jp)throws Throwable{
        try{
            Object rst=jp.proceed();
            log.info("进入增加！调用"+jp.getTarget()+"的"+jp.getSignature());
            return rst;
        }catch (Throwable e){
            log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"异常"+e);
            throw  e;
        }finally {
            log.info("最终增强！调用"+jp.getTarget()+"的"+jp.getSignature());
        }

    }
}

(4)、spring配置文件进行AOP相关的配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    
    <bean id="testLogger" class="pojo.TestLogger">bean>
    <aop:config>
        <aop:pointcut id="pointcut2" expression="execution(* biz.impl.UserBizImpl.add(pojo.User))">aop:pointcut>
        <aop:aspect ref="testLogger">
            
            <aop:before method="before1" pointcut-ref="pointcut2">aop:before>
            
            <aop:after-returning method="after1" pointcut-ref="pointcut2"
                                 returning="rst">aop:after-returning>
            
            <aop:after-throwing method="afterEx" pointcut-ref="pointcut2"
                                throwing="e">aop:after-throwing>
            
            <aop:around method="around" pointcut-ref="pointcut2">aop:around>
        aop:aspect>
    aop:config>
    <bean id="UserMapper" class="mapper.impl.UserMapperImpl">bean>

    <bean id="UserBizImpl" class="biz.impl.UserBizImpl">
        <property name="userMapper" ref="UserMapper">property>
    bean>

    <bean id="UserAction" class="action.UserAction">
        <property name="userBiz" ref="UserBizImpl">property>
    bean>
beans>

(5)、测试

ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
HelloSpring hs=(HelloSpring)context.getBean("bean元素里的id");

5、切入点表达式 execution(* com.sample.service.impl….(…))

整个表达式可以分为五个部分：

(1)、execution(): 表达式主体。

(2)、第一个*号：表示返回类型，*号表示所有的类型。

(3)、包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.sample.service.impl包、子孙包下所有类的方法。

(4)、第二个*号：表示类名，*号表示所有的类。

(5)、*(…):最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数。

6、JoinPoint类型参数

​ (1)、getTarget()方法获得被代理的目标对象

​ (2)、getSignature()方法获得返回代理的目标方法

​ (3)、getArgs()方法返回传递给目标方法的参数数组

四、注解

1、@Component注解
声明bean，等价于，@Component(“id”)，等价于

@Component能表示持久层、业务层、表现层的bean。为了更好分层开发，提供和@Component功能等价的3个注解，分层表示：

     @Repository ：dao层

     @Service：service层

     @Controller：控制器层

@Transactional声明事务处理

2、依赖注入
相关注解可以给私有字段设置，也可以给setter方法设置。

普通值：@Value("")
引用值：
1：按照类型注入
@Autowired
2：按照名称注入1
@Autowired
@Qualifier("名称")
3：按照名称注入2
@Resource(name="名称")

3、配置spring配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="action,biz"/>

五、事务

1、在spring配置文件中导入aop tx两个命名空间

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

2、配置文件的配置

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    bean>    
<tx:annotation-driven transaction-manager="txManager">tx:annotation-driven>

   <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            
            <tx:method name="add*" propagation="REQUIRED"/>
        tx:attributes>
    tx:advice>

    <aop:config>
       <aop:pointcut id="serviceMethod" expression="execution(* biz..*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod">aop:advisor>
    aop:config>

    
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver">property>
        <property name="url">
            
            <value>value>
        property>
        <property name="username" value="root">property>
        <property name="password" value="root">property>
    bean>

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        
       
    bean>

3、propagation事务传播机制：

传播行为	含义
REQUIRED	表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务
SUPPORTS	表示当前方法不需要事务上下文，但是如果存在当前事务的话，那么该方法会在这个事务中运行
MANDATORY	表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常
REQUIRED_NEW	表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务，在该方法执行期间，当前事务会被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager
NOT_SUPPORTED	表示该方法不应该运行在事务中。如果存在当前事务，在该方法运行期间，当前事务将被挂起。如果使用JTATransactionManager的话，则需要访问TransactionManager
NEVER	表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛出异常
NESTED	表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在，那么其行为与PROPAGATION_REQUIRED一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的文档来确认它们是否支持嵌套事务

4、isolation隔离级别

隔离级别	含义
DEFAULT	默认值
READ_UNCOMMITTED	未提交读
READ_COMMITTED	提交读
REPEATABLE_READ	可重复读
SERIALIZABLE	串行读