亲宝软件园·资讯

展开

Spring(IOC、AOP和事务)

1763392456 人气:0

目录

Spring介绍

Spring IOC

传统代码对象管理的弊端

实现过程

bean标签属性介绍

对象创建方式

工厂bean

bean的作用域

SpringBean的生命周期***

依赖注入

注解实现IOC

完全注解开发(JavaConfig)

Spring AOP

AOP的实现机制

JDK动态代理实现

CGlib代理

Spring中使用AOP

切入点方法的定义

获取切入点信息

使用AspectJ注解开发

Spring-JDBC 操作数据库

事务


Spring介绍

Spring是一个设计层面框架,他解决的是业务逻辑层和其他各层的松耦合问题,因此它将面向接口的编程思想贯穿整个系统应用。Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

 

特点

1.方便解耦,简化开发

通过Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。有了Spring,用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。

2.AOP编程的支持

通过Spring提供的AOP功能,方便进行面向切面的编程,许多不容易用传统面向对象实现的功能可以通过AOP轻松应付。

3.声明式事务的支持

在Spring中,我们可以从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活地进行事务的管理,提高开发效率和质量。

4.方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作,在Spring里,测试不再是昂贵的操作,而是随手可做的事情。例如:Spring对Junit4支持,可以通过注解方便的测试Spring程序。

5.方便集成各种优秀框架

Spring不排斥各种优秀的开源框架,相反,Spring可以降低各种框架的使用难度,Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz)等的直接支持。

6.降低Java EE API的使用难度

 

组织结构

ORM- object relation mapping

OXM-Object xml mapping

JMS - Java消息服务(Java Message Service ,JMS)

WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助HTTP请求完成。Socket是传输控制层协议,WebSocket是应用层协议。

Portlet是一种Web组件-就像servlets-是专为将合成页面里的内容聚集在一起而设计的。通常请求一个portal页面会引发多个portlets被调用。每个portlet都会生成标记段,并与别的portlets生成的标记段组合在一起嵌入到portal页面的标记内

spring全家桶:spring,Spring Data、Spring MVC、Spring Boot、Spring Cloud(微服务)

 

Spring核心模块

- spring-core:依赖注入IOC与DI的最基本实现

- spring-beans:Bean工厂与bean的装配

- spring-context:spring的context上下文即IoC容器

- spring-context-support

- spring-expression:spring表达式语言

 

Spring IOC

 

IOC是 Inverse of Control 的简写,意思是控制反转。是降低对象之间的耦合关系的设计思想。就是将对象统一管理,统一分配

 

传统代码对象管理的弊端

传统的调用方式时service层调用dao层,但是当我们的需求发生改变的时候,我们需要可能需要在写一个dao的实现类,然后再改变service的继承关系。但是这种改变源代码的方式不利于测试。我们可以用一种方式,就是把所有的对象提取出来,让一个容器来统一的管理。

 

实现过程

1、添加jar包

<!-- Spring的核心工具包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<!--在基础IOC功能上提供扩展服务,还提供许多企业级服务的支持,有邮件服务、 任务调度、远程访问、缓存以及多种视图层框架的支持-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<!-- Spring IOC的基础实现,包含访问配置文件、创建和管理bean等 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<!-- Spring context的扩展支持,用于MVC方面 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<!-- Spring表达式语言 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>

2、创建配置文件 applicationContext.xml (放在resource下面)

<?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">
</beans>

3、在配置文件中创建对象

<bean id="对象名" class="类的完整路径">
    <property name="属性名" ref="对象的id值"></property>
</bean>

4、加载配置文件,获得对象

ApplicationContext app=new ClassPathXmlApplicationContext("spring.xml"); 
Users users=(Users)app.getBean("u1");

举例:

模拟一个传统Service调用dao的过程

这里我们设计两个对象的调用过程, 我们可以把这两个对象写到配置文件中

首先new 两个对象

因为在UserServiceImpl中有个UserDao的属性

最后再在从配置文件中得到已经创建好的对象

注意:给属性赋值的时候,系统可以调用set方法,但是通过测试类得到属性的时候,只能调用配置文件

 

bean标签属性介绍

单列:每次拿到的对象都是同一个

对象创建方式

1、无参构造

2、有参构造

3、静态方法创建对象

4、非静态方法

 

工厂bean

spring有两种类型的bean,一种是普通的bean(和上面一样),另一种是工厂bean(FactoryBean)

普通bean:在配置文件中定义bean类型就是返回类型

工厂bean:配置文件中定义的类型和返回的类型不一样

实现步骤:

(1)创建类,让类实现FactoryBean接口

(2)实现接口方法,在实现的方法中定义bean的类型

 

bean的作用域

设置bean的实例是单例还是多例

单例(默认)
<bean id="myBean" class="com.vv.bean.MyBean" scope="singleton"></bean>
多例
<bean id="myBean" class="com.vv.bean.MyBean" scope="prototype"></bean>

设置指为singleton时:加载配置文件的时候就会创建对象

设置值为prototype时:在调用getBean方法的时候才创建多实例对象

 

SpringBean的生命周期***

1)根据配置文件调用 Bean 构造方法或工厂方法实例化 Bean。

2)利用依赖注入(DI)完成 Bean 中属性值的配置注入。

3)如果 Bean 实现了 BeanNameAware 接口,则 Spring 调用 Bean 的 setBeanName() 方法传入当前Bean 的 id 值。

4)如果 Bean 实现了 BeanFactoryAware 接口,则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。

5)如果 Bean 实现了 ApplicationContextAware 接口,则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。

6)如果 BeanPostProcessor 和 Bean 关联,则 Spring 将调用该接口的预初始化方postProcessBeforeInitialzation() 对Bean 进行加工操作,此处非常重要,Spring 的 AOP 就是利用它实现的。

7)如果 Bean 实现了 InitializingBean 接口,则 Spring 将调用 afterPropertiesSet() 方法。初始化bean的时候执行,可以针对某个具体的bean进行配置。afterPropertiesSet 必须实现 InitializingBean接口。实现 InitializingBean接口必须实现afterPropertiesSet方法。

8)如果在配置文件中通过 init-method 属性指定了初始化方法,则调用该初始化方法。

9)如果 BeanPostProcessor 和 Bean 关联,则 Spring 将调用该接口的初始化方法postProcessAfterInitialization()。此时,Bean 已经可以被应用系统使用了。

10)如果在中指定了该 Bean 的作用范围为 scope="singleton",则将该 Bean 放入 Spring IoC 的缓存池中,将触发 Spring 对该 Bean 的生命周期管理;如果在中指定了该 Bean 的作用范围为scope="prototype",则将该 Bean 交给调用者,调用者管理该 Bean 的生命周期,Spring 不再管理该Bean。

11)如果 Bean 实现了 DisposableBean 接口,则 Spring 会调用 destory() 方法将 Spring 中的 Bean销毁;如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法,则 Spring 将调用该方法对 Bean 进行销毁。

 

依赖注入

DI是Dependency Injection的缩写,意思是依赖注入,说的是创建对象实例时,同时为这个对象注入它所依赖的属性

分类:一种是调用属性的set方法赋值,第二种使用构造方法赋值

1、set注入指(调用属性的set方法)

2、构造方法注入

spel spring表达式

c、p命名空间

- 基本类型值: p:属性名="值"
- 引用类型值: P:属性名-ref="beanid"

3、复杂类型的注入(Object[],list,set,map,Properties类型)

    <bean id="t1" class="com.vv.bean.Teacher">
        <property name="objects">
            <list>
                <value>vv</value><!--字符串-->
                <value>19</value><!--数-->
                <ref bean="u1"></ref><!--引用类型-->
            </list>
        </property>
        <property name="list">
            <list>
                <value>xx</value><!--字符串-->
                <value>19</value><!--数-->
            </list>
        </property>
        <property name="set">
            <set>
                <value>77</value><!--字符串-->
                <value>19</value><!--数-->
                <ref bean="u1"></ref><!--引用类型-->
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="班长" value="77"></entry>
                <entry key="user" value-ref="u1"></entry><!--引用类型-->
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="username">root</prop>
                <prop key="password">123</prop>
            </props>
        </property>
    </bean>

4、自动装配(注入):Spring会在上下文中自动寻找,并自动给bean装配属性

autowire:

no 不自动装配(默认值)

byName 属性名=id名 ,调取set方法赋值  

byType 属性的类型和id对象的类型相同,当找到多个同类型的对象时报错,调取set方法赋值(保证id唯一)

constructor 构造方法的参数类型和id对象的类型相同,当没有找到时报错。调取构造方法赋值(保证class唯一)

 

注解实现IOC

1、配置文件中添加约束

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd

2、配置注解扫描:指定扫描包下所有类中的注解,扫描包时,会扫描包所有的子孙包

<!--扫描包设置--> 
<context:component-scan base-package="com.vv"></context:component-scan>

3、注解

(1)添加到类名上

@Component("对象名") :将某个类注册到Sping中,装配Bean
componet的衍生注解:
    @Service("对象名") // service层 
    @Controller("对象名") // controller层 
    @Repository("对象名") // dao层 

@Scope(scopeName="singleton") //单例对象 
@Scope(scopeName="prototype") //多例对象

(2)添加到属性

@Value("属性值") 
private String name;

@Autowired//默认使用byType,如果通过Repository注解了两个相同类型的对象就会报错
@Qualifier("uDao")//这样就可以指定对应的对象了
private UserDao userDao;

//@Resource(name="对象名") == @Autowired + @Qualifier("name")
@Resource(name="uDao")
private UserDao userDao;

注意:通过注解配置,对象里面的属性就不需要有set方法了

可能会没有Resource这个注解,需要加入依赖包

<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.1</version>
</dependency>

(3)添加到方法上

@PostConstruct //等价于init-method属性
public void init(){
    System.out.println("初始化方法");
}

@PreDestroy //等价于destroy-method属性
public void destroy(){
    System.out.println("销毁方法");
}

 

完全注解开发(JavaConfig)

1、创建配置类,替代xml配置文件

@Configuration//作为配置类,替代xml配置文件
@ComponentScan(basePackages = {"com.vv"})//开启组件扫描
public class SpringConfig {

}

2、加载配置类

ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);

此方法在springboot中使用

 

Spring AOP

AOP(Aspect Oriented Programming)即面向切面编程。即在不改变原程序的基础上为代码段增加新的功能。应用在权限认证、日志、事务。

AOP的作用在于分离系统中的各种关注点,将核心关注点和横切关注点分离开来。

想象下面的场景,开发中在多个模块间有某段重复的代码,我们通常是怎么处理的?显然,没有人会靠“复制粘贴”吧。在传统的面向过程编程中,我们也会将这段代码,抽象成一个方法,然后在需要的地方分别调用这个方法,这样当这段代码需要修改时,我们只需要改变这个方法就可以了。然而需求总是变化的,有一天,新增了一个需求,需要再多出做修改,我们需要再抽象出一个方法,然后再在需要的地方分别调用这个方法,又或者我们不需要这个方法了,我们还是得删除掉每一处调用该方法的地方。实际上涉及到多个地方具有相同的修改的问题我们都可以通过 AOP 来解决。

 

AOP的实现机制

- JDK 的动态代理:针对实现了接口的类产生代理。InvocationHandler接口

- CGlib 的动态代理:针对没有实现接口的类产生代理,应用的是底层的字节码增强的技术 生成当前类的子类对象,MethodInterceptor接口

JDK动态代理实现

创建接口实现类的代理对象,增强方法

//代理类
public class dai implements InvocationHandler {

    private UserService service;//目标对象

    public dai(UserService service) {
        this.service = service;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //本方法中的其他输出输入增强
        //proxy 代理方法被调用的代理实例
        System.out.println("日志开始");
        //调取真实的方法
        Object invoke = method.invoke(service, args);
        System.out.println("日志结束");
        return invoke;
    }
}
public class Test {
    public static void main(String[] args) {
        UserService service = new UserServiceImpl();

        dai d = new dai(service);
        //生成代理对象,这里不能转换成一个实际的类,必须是接口类型
        UserService us = (UserService) Proxy.newProxyInstance(service.getClass().getClassLoader(), service.getClass().getInterfaces(), d);
        us.insert(new User());
    }
}

CGlib代理

使用JDK创建代理有一个限制,它只能为接口创建代理实例.这一点可以从Proxy的接口方法 newProxyInstance(ClassLoader loader,Class [] interfaces,InvocarionHandler h)中看的很清楚,第二个入参 interfaces就是需要代理实例实现的接口列表.

CGLib采用底层的字节码技术,可以为一个类创建子类,在子类中完成类的增强

1、添加依赖包

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.5</version>
</dependency>

2、创建个工具类(代理器)

public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("日志开始");
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("日志结束");
        return o1;
    }
}

3、测试

public class Test {
    public static void main(String[] args) {
        Try t = new Try();
        //创建代理对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(t.getClass());
        enhancer.setCallback(new CglibProxy());
        Try t2 = (Try) enhancer.create();
        t2.test();
    }
}

两种代理方式的区别:

1、jdk动态代理生成的代理类和委托类实现了相同的接口;

2、cglib动态代理中生成的字节码更加复杂,生成的代理类是委托类的子类,且不能处理被final关键字修饰的方法;

3、jdk采用反射机制调用委托类的方法,cglib采用类似索引的方式直接调用委托类方法;

注:spring同时使用了这两种方式,底层会自行判断应该使用哪种

 

Spring中使用AOP

AOP中的术语

(1)连接点:类中可以被增强的方法

(2)切点:实际被真正增强的方法

(3)增强(通知):增强逻辑的部分(日志处理、权限判断)

(4)切面:把增强运用到切点的过程

步骤

1、添加依赖包

<dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>1.0</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.13</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>

2、创建增强类(本质上就是一个普通类)

public class MyAop {
    //前置增强-调用目标方法之前执行
    public void before(){
        System.out.println("日志开始");
    }

    //后置增强-调用目标方法之后执行
    public void after(){
        System.out.println("日志开始");
    }

    /**
     * @param joinPoint 获取切入点
     */
    public void around(ProceedingJoinPoint joinPoint){
        System.out.println("环绕开始");
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("环绕结束");
    }
    
    //异常增强
    public void ex(){
        System.out.println("异常增强");
    }
    
    //最终增强
    public void end(){
        System.out.println("最终增强");
    }
}

3、添加aop命名空间

xmlns:aop="http://www.springframework.org/schema/aop" 
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd

3、配置文件

增强类型:

前置增强:目标方法运行之前调用 aop:before

后置增强(如果出现异常不会调用):在目标方法运行之后调用 aop:after-returning

环绕增强:在目标方法之前和之后都调用 aop:around

异常增强:程序出现异常时执行(要求:程序代码中不要处理异常) aop:after-throwing

最终增强(无论是否出现 异常都会调用):在目标方法运行之后调用 aop:after

<bean id="udao" class="com.vv.dao.impl.UserDaoImpl"></bean>
<bean id="uService" class="com.vv.service.impl.UserServiceImpl" >
    <property name="userDao" ref="udao"></property>
</bean>

<!--创建增强类对象-->
<bean id="myaop" class="com.vv.util.MyAop"></bean>
<!--建立增强类和目标方法的关系-->
<aop:config>
    <aop:pointcut id="mypc" expression="execution(void com.vv.service.UserService.insert())"/>
    <aop:aspect ref="myaop">
        <!--前置增强-->
        <aop:before method="before" pointcut-ref="mypc"></aop:before>
        <!--后置增强-->
        <aop:after method="after" pointcut-ref="mypc"></aop:after>
        <!--环绕增强-->
        <aop:around method="around" pointcut-ref="mypc"></aop:around>
        <!--异常增强-->
        <aop:after-throwing method="ex" pointcut-ref="mypc"></aop:after-throwing>
        <!--最终增强-->
        <aop:after-returning method="end" pointcut-ref="mypc"></aop:after-returning>
    </aop:aspect>
</aop:config>

4、测试

ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService service = app.getBean("uService", UserService.class);
service.insert();

注意:(1)环绕增强需要使用ProceedingJoinPoint 作为参数(2)注意标签顺序

 

另一种方式

特殊的前置增强-->Advisor前置增强实现

(1)创建增强类,要求该类实现MethodBeforeAdvice接口

(2)设置配置文件,定义增强和切入点的关系

public class agency implements MethodBeforeAdvice {
    /**
     * @param method    要执行目标对象的方法
     * @param objects   参数
     * @param o         目标对象
     */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+" 的 "+method.getName()+" 被执行了");
    }
}
<bean id="userDao" class="com.vv.dao.Impl.UserDaoImpl"></bean>
<bean id="agency" class="com.vv.agency"></bean>
<aop:config>
    <!--切入点-->
    <aop:pointcut id="pointcut" expression="execution(* com.vv.dao.Impl.*.*(..))"/>
    <aop:advisor advice-ref="agency" pointcut-ref="pointcut"/>
</aop:config>

切入点方法的定义

表达式匹配规则举例:

1、public * addUser(com.pb.entity.User):“*”表示匹配所有类型的返回值。

public int addUser(User u); 
public String addUser(User u);

2、public void *(com.pb.entity.User):“*”表示匹配所有方法名

public void selectUser(User u); 
public void a(User u);

3、public void addUser (..):“..”表示匹配所有参数个数和类型。

public void addUser(int a); 
public void addUser(int b,int c);

4、com.pb.service.*.*(..):匹配com.pb.service 包下所有类的所有方法。

public void com.pb.service.A.a(); 
public String com.pb.service.B.a();

5、* com.pb.service..*(..):匹配com.pb.service 包及子包下所有类的所有方法

 

 

获取切入点信息

通过JoinPoint对象获取信息

public void before(JoinPoint joinPoint){
    System.out.println("日志开始");
    System.out.println(new Date());
    System.out.println("对象信息:"+joinPoint.getTarget().getClass().getSimpleName());
    System.out.println("方法信息:"+joinPoint.getSignature());
    System.out.println("参数信息:"+joinPoint.getArgs());
}

 

使用AspectJ注解开发

1、启动扫描Spring注解的包,启动aspectJ的注解方式

<!--扫描Spring注解包-->
<context:component-scan base-package="com.vv"></context:component-scan>
<!--开启aspectj,生成代理对象-->
<aop:aspectj-autoproxy/>

2、增强类使用@Componet注解,添加@Aspect

3、在增强类中定义切点,指明要修饰的方法

@Component
@Aspect    //生成代理对象
public class MyAop {

    //定义切点,由于注解必须修饰方法,所以这里要定义一个空方法
    @Pointcut("execution(* com.vv.service.*.*(..))")
    public void p(){}

    //前置增强-调用目标方法之前执行
    @Before("p()")
    public void before(){
        System.out.println("日志开始");
    }

    //后置增强-调用目标方法之后执行
    @AfterReturning("p()")
    public void after(){
        System.out.println("日志结束");
    }

    /**
     * @param joinPoint 获取切入点
     */
    @Around("p()")
    public void around(ProceedingJoinPoint joinPoint){
        System.out.println("环绕开始");
        try {
            joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("环绕结束");
    }

    //异常增强
    @AfterThrowing("p()")
    public void ex(){
        System.out.println("异常增强");
    }

    //最终增强
    @After("p()")
    public void end(){
        System.out.println("最终增强");
    }
}

或者直接这样使用

注解方式中注解的顺序

 

Spring-JDBC 操作数据库

导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.46</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.2</version>
</dependency>

原始的使用方式:

public class demo1 {
    public static void main(String[] args) throws PropertyVetoException {
        //1.创建c3p0链接池
        ComboPooledDataSource dataSource=new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/try");
        dataSource.setUser("root");
        dataSource.setPassword("");
        //创建jdbcTemplate对象
        JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
        //创建sql语句
        String sql="insert into users values (?,?,?);";
        jdbcTemplate.update(sql, 4, "vv", "321");
    }
}

Spring管理jdbcTemplate

让dao实现类继承JdbcDaoSupport,父类中可以提供jdbcTemplate对象

然后修改配置文件,在配置文件中配置数据源信息

<bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/try"/>
    <property name="user" value="root"/>
    <property name="password" value=""/>
</bean>

<bean id="userDao" class="com.vv.dao.Impl.UserDaoImpl">
    <property name="dataSource" ref="ds"></property>
</bean>

dao实现类

public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
    @Override
    public int insert(User user) {
        String sql = "insert into users values (?,?,?);";
        int usid = user.getUsid();
        String username = user.getUsername();
        String password = user.getPassword();
        int update = getJdbcTemplate().update(sql, usid, username, password);
        return update;
    }
}

之前我们是吧数据库的配置信息放在properties文件中,我们这里也可以用同样的方式

jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/try
username=root
password=

配置文件

<context:property-placeholder location="classpath:jdbc.properties" system-properties-mode="FALLBACK"></context:property-placeholder>

<bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driver}"/>
    <property name="jdbcUrl" value="${url}"/>
    <property name="user" value="${username}"/><!--这里的username默认调用的系统的username,在上面添加system-properties-mode="FALLBACK-->
    <property name="password" value="${password}"/>
</bean>

<bean id="userDao" class="com.vv.dao.Impl.UserDaoImpl">
    <property name="dataSource" ref="ds"></property>
</bean>

CRUD操作操作

public class UserDaoImpl extends JdbcDaoSupport implements UserDao {
    @Override
    public int insert(User user) {
        String sql = "insert into users values (?,?,?);";
        int usid = user.getUsid();
        String username = user.getUsername();
        String password = user.getPassword();
        int update = getJdbcTemplate().update(sql, usid, username, password);
        return update;
    }

    @Override
    public User findbyid(int id) {
        String sql ="select * from users where usid = ?";
        User user = getJdbcTemplate().queryForObject(sql, new Object[]{id}, new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User user = new User();
                user.setUsid(resultSet.getInt("usid"));
                user.setUsername(resultSet.getString("username"));
                user.setPassword(resultSet.getString("password"));
                return user;
            }
        });
        return user;
    }

    @Override
    public List<User> findAll() {
        String sql = "select * from users";
        List<User> list = getJdbcTemplate().query(sql, new RowMapper<User>() {
            @Override
            public User mapRow(ResultSet resultSet, int i) throws SQLException {
                User user = new User();
                user.setUsid(resultSet.getInt("usid"));
                user.setUsername(resultSet.getString("username"));
                user.setPassword(resultSet.getString("password"));
                return user;
            }
        });
        return list;
    }

    @Override
    public int update(int id, User user) {
        String sql = "update users set username = ?, password = ? where usid =?";
        int update = getJdbcTemplate().update(sql,user.getUsername(),user.getPassword(),id);
        return update;
    }

    @Override
    public int delete(int id) {
        String sql = "delete from users where usid = ?";
        int update = getJdbcTemplate().update(sql, id);
        return update;
    }
}

 

事务

通过sql将逻辑相关的一组操作绑定在一起,以便服务器 保持数据的完整性(准确性)。

事务通常是以begin transaction开始,以commit或rollback结束。

事务执行的流程:开启事务->执行insert,update,delete->commit/rollback

事务的特性ACID

1 - 原子性(atomicity)

事务是数据库的逻辑工作单位,而且是必须是原子工作单位,对于其数据修改,要么全部执行,要么全部不执行。

2、一致性(consistency)

事务在完成时,必须是所有的数据都保持一致状态。在相关数据库中,所有规则都必须应用于事务的修改,以保持所有数据的完整性。

3、隔离性(isolation)

一个事务的执行不能被其他事务所影响。企业级的数据库每一秒钟都可能应付成千上万的并发访问,因而带来了并发控制的问题。

4、持久性(durability)

一个事务一旦提交,事务的操作便永久性的保存在DB中。即使此时再执行回滚操作也不能撤消所做的更改

 

事务传播行为propagation

 

多事务方法(对数据库数据进行改变)之间进行调用,这个过程中事务是如何进行管理的。

当事务方法被另一个事务方法调用时,必须指定事务应该如何传播。规定了事务方法和事务方法发生嵌套调用时事务如何进行传播例如:方法可能继续在现有事务中运行,也可能开启一个新事务,并在自己的事务中运行。

七种传播行为*

事务传播行为失效的情况

spring事务是基于代理来实现的,所以:

(1)private、fifinal、static 方法无法被代理,所以添加事务无效

(2)当绕过代理对象, 直接调用添加事务管理的方法时, 事务管理将无法生效。比如直接new出的对象。

(3)在同一个类下,有2个方法,A、B,A没有事务,B有事务,但是A调用B时,方法B被标记的事务无效。 究其原因,因为此类的调用对象为代理对象,代理方法A调用真正的被代理方法A后,在被代理方法A中才会去调用方法B,此时this对象为被代理的对象,所以是不会通知到代理对象,也就变成了第二种情况,绕过了代理对象。所以无事务隔离级别

 

事务的隔离级别

脏读:读取到一个未提交事务的数据,若事务回滚可能导致数据不一致

不可重复读:一个未提交的事务两次读取的数据不一致

幻读:一个未提交的事务读取到另一个提交事务添加数据

1. Serializable(串行化):可避免脏读、不可重复读,幻读情况的发生。

2. Repeatable read(可重复读):可避免脏读、不可重复读情况的发生。

3. Read committed(读已提交):可避免脏读情况发生。

4. Read uncommitted(读未提交):最低级别,以上情况均无法保证。

 

 

 

事务操作(Spring事务管理)

一般添加到JavaEE三层结构里面的Service层

有两种事务管理操作:编程式事务管理(在代码前后添加代码,不常用)和声明式事务管理(常用)

声明式事务管理(底层使用到了AOP):

1、基于注解

修改配置文件

<!--创建事务管理器-->
<bean id="manager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="ds"/>
</bean>
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="manager"></tx:annotation-driven>

添加注解

注解中可配置的参数

propagation:事务传播行为(默认Propagation.REQUIRED)

isolation:隔离级别

timeout:超时时间(在一定时间不提交就会回滚,默认-1不超速)

readOnly:是否只读(默认false,可以进行增伤改查,true:只能查询)

rollbackFor:回滚

norollbackFor:不回滚

2、基于XML

<!--创建事务管理器--><!--这里id好像必须写成transactionManager-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="ds"/>
</bean>

<!--配置增强-->
<tx:advice id="txAdvice">
    <tx:attributes>
        <!--哪种规则的方法添加事务-->
        <tx:method name="insert*" propagation="REQUIRED"/><!--以insert开头的方法-->
        <tx:method name="update*" read-only="true"/>
    </tx:attributes>
</tx:advice>
<!--配置切入点和切面-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="mypoint" expression="execution(* com.vv.service.*.*(..))"/>
    <!--切面   把事务通知配置到切点上-->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="mypoint"></aop:advisor>
</aop:config>

 

加载全部内容

相关教程
猜你喜欢
用户评论