Spring_正式1-优快云博客

本文链接：https://blog.youkuaiyun.com/qi_index/article/details/119647710

这篇博客介绍了Spring框架的依赖注入（DI）和核心容器（IOC）的概念，详细讲解了如何通过XML配置和注解实现Bean的创建和管理。此外，还探讨了AOP（面向切面编程）的应用，包括动态代理、通知类型以及事务管理。内容涵盖了基于XML和注解的事务配置，并提供了JdbcTemplate的使用示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

dependency injection依赖注入di

core Container核心容器 IOC

AOP

Test

Data Access/Integeration

Web

day01: IOC,DI

maven:

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.9</version>
</dependency>

pom.xml

传统的JDBC:

注册驱动
获取连接
获取操作数据库的预处理对象
执行SQL
遍历结果集
释放资源

解耦的思路:

1 使用反射来创建对象,而避免使用new关键字

2 通过读取配置文件来获取创建对象的全限定类名

Bean:

在计算机中,有可重用组件的含义;

JavaBean:用java写的可重用组件;比实体类范围更大;

它就是创建service和配置dao对象的;

一控制反转:IOC

原理:

核心:DI依赖注入

原理. spring ioc容器原理是根据Java的反射机制，获取类的所有信息，再通过xml或者注解配置获取类与类之间的关系，最后根据以上信息构建类与类之间的依赖。. 容器加载bean原理如下：. 根据xml、注解获取bean的配置信息，在容器内部创建注册表. 根据注册表实例化bean，并创建bean与bean之间的依赖. 将初始化的bean保存在容器的缓存中（hashmap），等待客户端调用（bean的作用域为singleton，如果为prototype多例则不缓存直接返回）

1pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>day01-eesy-02fantory</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>



    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!--根据个人需要自己修改-->
                    <source>9</source>
                    <target>9</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

2ApplicationContentext的三个常用实现类

ApplicationContentext的三个常用实现类
  1   ApplicationContext ac= new ClassPathXmlApplicationContext("bean.xml");
这个可以加载类路径下的配置文件;要求配置文件必须在类路径下;不在的话,加载不了;
	2   ApplicationContext ss = new FileSystemXmlApplicationContext("D:\D Computer sth  for download\kuangjia\day01-eesy-02fantory\src\main\resourcesbean.xml");
这个可以加载任意路径下的配置文件
    3:用于读取注解创建容器的;
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService as = ac.getBean( "accountService",IAccountService.class)

3核心容器的两个接口引发的问题:

(1) ApplicationContext:(多用此接口)

创建的对象;立即加载;单例对象适用,

(2)BeanFactory:(顶层类)

延迟加载;多例对象适用;

4:Bean.xml

<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="accountService" class="com.itheima.service.impl.AccountSurviceImpl"></bean>
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
</beans>

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

    <!--创建Bean的三种方式-->

    <bean id="accountService" class="com.itheima.service.impl.AccountSurviceImpl"></bean>

    <!--第二种-->
    <bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

    
    <!--第三种是类中的获取类的方法静态方法-->
    <bean id="accountServer" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>
</beans>

6bean的作用范围:

(1)scope的属性:在bean.xml中配置

    <bean id="accountService" class="com.itheima.service.impl.AccountSurviceImpl" scope="singleton">

singleton 是单例;默认是
prototype:多例
request:web应用的请求范围
session:web应用的会话范围欧
global-session:作用于集群的会话范围;无集群的时候是session;有负载均衡的时候,分担压力;

7bean的生命周期:

单例对象:

容器创建时出生,
死亡:容器销毁,则对象消亡
活着:
总结:单例对象的生命周期和容器相同;

多例对象:

出生当使用对象是Spring框架就为我们创建

活着

死亡:当对象长时间不用,jvm的垃圾回收机制回收;

二依赖注入dependency injection

针对于不是默认构造函数的,有自己是有参数构造函数的;

1constructor-arg的标签的6种属性:

有6个标签

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


    <bean id="accountService" class="com.itheima.service.impl.AccountSurviceImpl">
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="name" value="张建庄"></constructor-arg>
        <constructor-arg name="birthday" ref="time"></constructor-arg>
    </bean>
    <bean id="time" class="java.util.Date"></bean>

</beans>

优势:在获取bean对象时,注入数据是必须的要求;否则创建不成功;

劣势:在不需要这些对象的时候,用不到的时候也要提供

2set属性:(常用)

 <!--set标签的位置-->
    <bean id="accountService2" class="com.itheima.service.impl.AccountSurviceImpl">
        <property name="userName" value="test"></property>
        <property name="age" value="23"></property>
        <property name="birthday" ref="time"></property>
    </bean>

只有三个属性,

优势:不用有参数的构造方法;默认的就行

劣势:如果有个值需要有值,但是有可能set方法没有执行

3复杂类型的依赖注入

List集合注入的:list array set

map的集合:map props

 <!--set标签的位置 复杂类型 数组-->
    <bean id="accountService3" class="com.itheima.service.impl.AccountSurviceImpl3">
     <property name="myStringArrays">
         <array>
             <value>AAA</value>
             <value>bbb</value>
             <value>ccc</value>
         </array>
     </property>
    </bean>

day02: 注解

今日学习内容:

Spring基于注解的IOC和IOC案例
常用注解
案例使用xml方式和注解方式实现单表的CRUD的操作
- 持久层:dbutils
改造基于注解的IOC案例;使用纯注解的方式实现
- 一些新注解的使用
SPring和Junit整合

一:11个注解

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hLNofjQP-1628757106561)(C:\Users\12479\AppData\Roaming\Typora\typora-user-images\image-20210805153106740.png)]

2注解的bean.xml

搜索位置如上图片;

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.itheima"></context:component-scan>

</beans>

3注解分类:

 1都用于吧把当前类对象存入Spring容器中;
*类似于xml中的<bean>标签</bean>
* @Component
@Repository     持久层
@Controller     biaoxianceng 
@Service        shiwuceng
* 2 注入数据的:
 * 类似于xml的<property>标签</property>
* @Autowired 
*
*/
     
     
     /**
 * 1都用于吧把当前类对象存入Spring容器中;
        *类似于xml中的<bean>标签</bean>
        *(1) @Component
@Repository    
@Controller
@Service
 * 2注入数据的:
         * 类似于xml的<property>标签</property>
 * (1)Autowired:
 * @Qualifier:
 *    属性value:需要和第一个@Autowired配合使用
 * @Resource
 *    属性name:直接写需要的那个bean名字
 * (2)用于基本类型的注入和String类型的数据
 * Value:
 *      属性value: 用于指定数据的值,可以使用spring中SpEL;${表达式}
 *
 *3用于改变范围的:类似xml中的<scope>标签</scope>
 * @Scope("prototype")
 *4    和生命周期相关的
 * @PreDestroy
 *   @PostConstruct 初始化相关
 *     @PostDostroy
 */

3.2@qualifier:

(1)在类需要配合@Autowired使用;(配合动态代理;)

(2)在方法参数可以独立使用;

 public QueryRunner creteQueryRunner  (@Qualifier("dataSource") DataSource dataSource){
        return new QueryRunner(dataSource);

4pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>org.example</groupId>
<artifactId>day01-eesy-02fantory</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.9</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.4</version>
    </dependency>
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.1.2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.10</version>
        <scope>test</scope>
    </dependency>

</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <!--根据个人需要自己修改-->
                <source>9</source>
                <target>9</target>
            </configuration>
        </plugin>
    </plugins>
</build>


</project>

5另一些注解

**
 * 配置类,作用和bean.xml是一样的
 * @Configuration
 * 说明是配置类
 * @ComponentScan
 *  value:用于指定Spring在创建时要扫描的包
 *  
 * @Bean
 * 用于把当前方法的返回值作为bean对象存入Spring的ioc容器中
 * 属性:
 *         name:用于指定bean的id,当不写的时候,就是默认当前方法的名称;
          name:用于指定bean的id,当不写的时候,就是默认当前方法的名称;
 *  细节:当我们使用注解配置方法时,如果有参数;Spring会去容器中查找有没有可用的Bean对象;有就注入;
 *  查找方式和Autwired注解一样,
 */

@Scope("prototype")多李

5.2:

@Import(类.class)

@Import(Jdbcconfig.class)//在这个父配置类,中可以导入其他的子配置

5.3

加入配置文件properties;来解耦密码;用户等;

@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {
    @Value("${jdbc.driver}")
     private String driver;
    
   @Value("${jdbc.url}")
     private  String url;
   
   @Value("${jdbc.user}")
     private  String user;
     
   @Value("${jdbc.password}")
     private  String password;

6一个配置类:

package config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * 配置类,作用和bean.xml是一样的
 * @Configuration
 * 说明是配置类
 * @ComponentScan
 *  value:用于指定Spring在创建时要扫描的包
 *
 * @Bean
 * 用于把当前方法的返回值作为bean对象存入Spring的ioc容器中
 * 属性:
 *         name:用于指定bean的id,当不写的时候,就是默认当前方法的名称;
 *  细节:当我们使用注解配置方法时,如果有参数;Spring会去容器中查找有没有可用的Bean对象;有就注入;
 *  查找方式和Autwired注解一样,
 */
@Configuration
@Import(Jdbcconfig.class)//在这个父配置类,中可以导入其他的子配置
@ComponentScan(basePackages ={"com.itheima"})
public class SpringConfiguration {

    @Bean(name = "runner")
    @Scope("prototype")
    public QueryRunner creteQueryRunner (DataSource dataSource){
        return new QueryRunner(dataSource);
    }
    @Bean(name = "dataSource")
    public DataSource createDataSource(){
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/eesy");
            ds.setUser("root");
            ds.setPassword("root");
            return ds;
        } catch (Exception e) {
            e.printStackTrace();
           // throw new IndexOutOfBoundsException("有错误");\
            throw  new RuntimeException(e);
        }
    }
}

7注解的一些细节:

7.1测试类:

//在注解中;用这个方式,不能用xml的那种;
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        IAccountService as = ac.getBean( "accountService",IAccountService.class);####

package com.itheima.test;

import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import config.SpringConfiguration;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * Junit整合SPring
 * 导入junit的坐标
 * 使用@Runwith;替换main这种类;
 */

@RunWith(SpringJUnit4ClassRunner.class)
public class AccountServiceTest {
    private  ApplicationContext ac;
    private IAccountService as;

    @Before
    public void init(){
        //注解用 这个获取ac;
        ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        as = ac.getBean( "accountService",IAccountService.class);

    }

    @Test
    public void testFindAll() {

        //ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        List<Account> accounts = as.findAllAccount();
        for(Account account:accounts) {
            System.out.println(account);
        }
    }
    @Test
    public void testFindOne() {

    }
    @Test
    public void testSave() {

    }
    @Test
    public void testDelete() {

    }
}

7.2新版本的测试类:

package com.itheima.test;

import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import config.SpringConfiguration;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

/**
 * Junit整合SPring
 * 导入junit的坐标
 * 使用@Runwith;替换main这种类;
 * 告知用的注解还是xml方式,并且说明位置
 *          classes:为注解类的位置
 *          locations:指定为xml的文件的位置;加上classpath关键字;表示在类路径下
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {
   // private  ApplicationContext ac;
    @Autowired
    private IAccountService as;

    @Test
    public void testFindAll() {
        List<Account> accounts = as.findAllAccount();
        for(Account account:accounts) {
            System.out.println(account);
        }
    }
    @Test
    public void testFindOne() {

    }
    @Test
    public void testSave() {

    }
    @Test
    public void testDelete() {

    }
}

7.3新版的pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>day01-eesy-02fantory</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!--根据个人需要自己修改-->
                    <source>9</source>
                    <target>9</target>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

二:Junit配合Spring;整合

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {
      @Autowired
    private IAccountService as;

Junit整合SPring
 导入junit的坐标
 使用@Runwith;替换main这种类;
 告知用的注解还是xml方式,并且说明位置
         classes:为注解类的位置
          locations:指定为xml的文件的位置;加上classpath关键字;表示在类路径下

Junit整合SPring

导入junit的坐标
使用@Runwith;替换main这种类;
告知用的注解还是xml方式,并且说明位置
classes:为注解类的位置
locations:指定为xml的文件的位置;加上classpath关键字;表示在类路径下

(2)设置完毕,就可以在测试类中使用@Autowired注解了;

day03 AOP

1今日内容:

回顾:动态代理;
完善account案例
动态代理的另一种实现方式,

2动态代理:

1:作用:不修改源码的基础上对方法增强;

2分类:

接口的代理

子类的代理

3基于接口的代理:

涉及类:Proxy

提供者:JDK官方

4如何创建代理对象:

newProxyInstance方法

5:要求:

**被代理类最少实现一个接口,**必要要实现一个

6 newProxyInstance方法参数:

ClassLoader:类加载器:用于加载代理对象字节码的;
- 写的是被代理对象的类加载器;固定写法
Class[]字节码数组:用于让代理对象和被代理对象有相同的方法,
- 固定写法
InvocationHandler:用于提供增强的代码;
- 通常为匿名内部类;但不是必须的;谁用数写;

7new InvocationHandler()的参数:

package com.itheima.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

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

         final Producer producer = new Producer();

         /**
         * ## 2动态代理:
         *
         * 1:作用:不修改源码的基础上对方法增强;
         *
         * 2分类:
         *
         * 接口的代理
         *
         * 子类的代理
         *
         *
         *
         * 3基于接口的代理:
         *
         * 涉及类:Proxy
         *
         * 提供者:JDK官方
         *
         * 4如何创建代理对象:
         *
         *  newProxyInstance方法
         *
         * 5:要求:
         *
         * 被代理类最少实现一个接口,
         *
         * 6  newProxyInstance方法参数:
         *
         * +   ClassLoader:类加载器:用于加载代理对象字节码的;
         *     +   写的是被代理对象的类加载器;固定写法
         * +   Class[]字节码数组:用于让代理对象和被代理对象有相同的方法,
         *     +   固定写法
         * +   InvocationHandler:用于提供增强的代码;
         *     +   通常为匿名内部类;但不是必须的;谁用数写;
         *
         * 7new InvocationHandler()的参数:
         */
       IProducer proxyProducer = (IProducer)Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(),
                /**
                 *
                 */
                new InvocationHandler() {
                    @Override
                    /**
                     *
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //增强的代码:
                         Object returnValue=null;
                        Float money= (Float)args[0];
                        if("saleProduct".equals(method.getName())) {
                            returnValue = method.invoke(producer, money * 0.8f);
                        }
                        try {

                        }catch (Exception e){
                            throw new  RuntimeException("ee");
                        }
                        return returnValue;
                    }
                });
        proxyProducer.saleProduct(10000f);
    }
}

(8)基于子类的代理方式:

需要导包:

   <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>

提供者:第三方cglib库:

使用Enhancer类中的create方法;

要求:被代理类不能是最终类

package com.itheima.cglib;

import com.itheima.proxy.IProducer;
import com.itheima.proxy.Producer;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

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

         final Producer producer = new Producer();
         //基于子类的动态代理
        Producer cglibPRoducer  = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)
                    throws Throwable {
                Object returnValue = null;
              Integer money= (Integer)args[0];
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer, money * 0.8);
                }
                return returnValue;
            }
        });
        cglibPRoducer.saleProduct(455);

    }
}

3AOP 面向切面编程;

实现方式:动态代理;

通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术;

简答来说;就是它把我们程序重复的代码抽取抽取;在需要执行的时候,使用动态代理技术;在不修改源码基础上;对我们已有的方法进行增强;

4Spring中的AOP(掌握)

4-1aop的相关术语:

aspect切面:

连接点: join[ot
切入点; pointcut
前置通知;后置通知;异常通知;最终通知-------环绕通知
advice 通知;提供公共代码的类
织入;weaving;是指把增强应用到目标对象来创建新的代理对象的过程
引介
切面:是切入点和通知(引介)的结合:

4-2:

5:基于xml的AOP配置步骤

5.1pom.xml

切入点联盟:解析语言的;

切面注解的;也要需要

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

bean.xml

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    

</beans>

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--配置spring的ioc,把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    <!---->


    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <aop:aspect id="logAdvice" ref="logger" >
            <aop:before method="printLog" pointcut="execution(public void com
            .itheima.service.impl.AccountServiceImpl.saveAccount())"></aop:before>
        </aop:aspect>
    </aop:config>

</beans>

说明:用xml也可以实现动态代理的功能;

5.4切入点的通配符写法:

<aop:aspect id="logAdvice" ref="logger" >
            <!--* *..*.*(..)-->
            <!--execution(public void com
            .itheima.service.impl.AccountServiceImpl.saveAccount())-->

    
    zheg :
            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
            <!--实际切入点表达式的通常写法:s-->

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--配置spring的ioc,把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    <!---->


    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <aop:aspect id="logAdvice" ref="logger" >
            <!--* *..*.*(..)-->
            <!--execution(public void com
            .itheima.service.impl.AccountServiceImpl.saveAccount())-->

            <aop:before method="printLog" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
            <!--实际切入点表达式的通常写法:-->
        </aop:aspect>
    </aop:config>

</beans>

6:四种类型的adviceType通知类型:

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--配置spring的ioc,把service对象配置进来-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
    <!---->


    <bean id="logger" class="com.itheima.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切入点表达式;id用于指定表达式-->
        <!--如果写在aspect的外面,就要写在aspect的前面-->
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.impl.*.*(..))"/>

        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger" >
            <!--* *..*.*(..)-->
            <!--execution(public void com
            .itheima.service.impl.AccountServiceImpl.saveAccount())-->
            <!--前置通知-->
            <!--实际切入点表达式的通常写法:-->
            <aop:before method="printLog" pointcut=
                    "execution(* com.itheima.service.impl.*.*(..))"></aop:before>
          <!--后置通知-->
            <!--异常通知和后置通知只能有一个发生-->
            <aop:after-returning method="printLog" pointcut-ref="pt1"></aop:after-returning>
            <!--异常通知-->
            <aop:after-throwing method="printLog" pointcut-ref="pt1" ></aop:after-throwing>
            <!--最终通知-->
            <aop:after method="printLog" pointcut=
                    "execution(* com.itheima.service.impl.*.*(..))"></aop:after>
            
    </aop:aspect>

    </aop:config>

</beans>

6.1环绕通知:(重要)

动态代理有明确的invoke方法调用,

xml中,Spring提供了一个接口,也可以调用;PrinceedingJoinPoint.

//环绕通知
    public Object  aroundPringLog(MethodInvocationProceedingJoinPoint pjp){
        Object reValue =null;
        try {
            Object[] args =pjp.getArgs();
            pjp.proceed(args);//明确调用业务层方法(切入点方法)
            System.out.println("环绕通知方法执行了" );
            return reValue;
        }catch (Throwable t ){
            throw new  RuntimeException("eee");
        }
        finally {
        }
    }

7注解的方式:aOP

bean.xml

要有aop和context两个,和另外的不一样;

<?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:aop="http://www.springframework.org/schema/aop"
       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/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd">


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


       <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

针对于注解,!@Around切面注入点,切入点,等,需要导入 aspectj这个

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.8.M1</version>
    <scope>runtime</scope>
</dependency>

longger.java的切面类

package com.itheima.utils;

import org.aspectj.lang.annotation.*;
import org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint;
import org.springframework.stereotype.Component;

@Component("logger")
@Aspect//切面类
public class Logger {
    @Pointcut("execution(* com.itheima.service.impl.*.*(..))")
    private  void pt1(){

    }
    @Before("execution(* com.itheima.service.impl.*.*(..))")
    public  void printLog(){
        System.out.println("printLog开始执行记录日志");
    }
    
    @AfterReturning()
    public void sss(){
        System.out.println("eeee");
    }
    @After("pt1()")
    public  void ddd(){
        System.out.println("dddd");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>day03-eesy-03SpringAOP</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>

        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!--根据个人需要自己修改-->
                    <source>9</source>
                    <target>9</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

day04

1spring中的JdbcTemplate

2spring中的事务控制;

需要导入的包;事务和jdbcTemplate的;pom.xml

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>

一JdbcTemplate:

作用:

就是用于和数据库交互的;

如何创建:

常用方法:

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

    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root">
        </property>
        <property name="password" value="root"></property>
    </bean>

    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>


</beans>

package com.itheima.dao.Impl;

import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

class AccountDaoImpl implements IAccountDao {
    
    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Account findAccountByname(String accountName) {
        List<Account> accounts = jdbcTemplate.query("selecet * from account where name = ?",
                new BeanPropertyRowMapper<Account>(Account.class), accountName);
        if (accounts.isEmpty()){
            return  null;
        }
        if (accounts.size()>1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }
}

JdbcDaoSupport类

可以减少代码写;定义好的jdbcTemplate;获取可以使用;以及dataSource;

二spring事务:

使用配置:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>day04-eesy-01</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.7</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.8.M1</version>

        </dependency>
   

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.16.RELEASE</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
  


    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <!--根据个人需要自己修改-->
                    <source>9</source>
                    <target>9</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>day04-eesy-04tx</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>

        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.9</version>
</dependency>

    </dependencies>


</project>

DBUtils是java编程中的数据库操作实用工具，小巧简单实用。

DBUtils封装了对JDBC的操作，简化了JDBC操作。可以少写代码。

1.对于数据表的读操作，他可以把结果转换成List，Array，Set等java集合，便于程序员操作;

2.对于数据表的写操作，也变得很简单(只需写sql语句)

3.可以使用数据源，使用JNDI，数据库连接池等技术来优化性能–重用已经构建好的数据库连接对象

QueryRunner类

ResultSetHandler接口

QueryRunner类

QueryRunner中提供对sql语句操作的API.

QueryRunner(DataSource ds) ---- 将连接池给DBUtils框架，以后每个操作，都会从连接池中获取一个新的连接 (每条SQL 一个单独的事务)

它主要有三个方法

query()用于执行select

update()用于执行insert update delete

batch()批处理可执行多条语句批量

ResultSetHandler接口

用于定义select操作后，怎样封装结果集.返回list_arrayset

Dbutils快速入门
————————————————
版权声明：本文为优快云博主「QF大数据」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qianfeng_dashuju/article/details/80513250

1xml事务

事务管理器
配置事务的通知;
- 导入约束;tx名称的xml;也要aop的;

配置aop切入点表达式:

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="accountservice" class="com.itheima.service.Impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <bean id="accountDao" class="com.itheima.dao.Impl.AccountDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>

    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager
"></bean>

    <!--配置事物通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--配置事物的属性-->
        <!--
        isolation:隔离级别;默认是DEFAULT,数据库的迷人隔离级别
        propagation:传播行为;默认是有事物:required;
        read-only: 只有查询方法是ture
        timeout:
        roollback -for:
        
        
        -->
        <tx:attributes>
            <tx:method name="transfer" propagation="REQUIRED" read-only="false"/>
            <!--方法很多的时候:可以写通配符*-->
            <tx:method name="find*" read-only="true" propagation="REQUIRED"></tx:method>
        </tx:attributes>
    </tx:advice>
    <!--配置切入点-->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.itheima.service.Impl.*.*(..))"/>
        
        <!--切入点和事物的对应关系-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
        
    </aop:config>
    
    <
</beans>

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
  
      <groupId>org.example</groupId>
      <artifactId>day04-eesy-04tx</artifactId>
      <version>1.0-SNAPSHOT</version>
  
      <dependencies>
  
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>5.0.2.RELEASE</version>
  
          </dependency>
  
  
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-test</artifactId>
              <version>5.0.2.RELEASE</version>
          </dependency>
          <dependency>
              <!--sPring事务的-->
              <groupId>org.springframework</groupId>
              <artifactId>spring-tx</artifactId>
              <version>5.0.2.RELEASE</version>
          </dependency>
  
          <dependency>
              <!--链接mysql的-->
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.25</version>
          </dependency>
  
  
          <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
          <dependency>
              <!--jdbc等dataSourvce等jdbcTemplate-->
              <groupId>org.springframework</groupId>
              <artifactId>spring-jdbc</artifactId>
              <version>5.3.9</version>
          </dependency>
          <dependency>
              <!--aop中的注解等-->
              <groupId>org.aspectj</groupId>
              <artifactId>aspectjweaver</artifactId>
              <version>1.8.7</version>
          </dependency>
          <dependency>
              <!--test包下的测试类中的测试注解等-->
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.12</version>
          </dependency>
      </dependencies>
  
      <!--解决运行起来的时候是jdk1.5的问题.-->
      <build>
          <plugins>
              <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-compiler-plugin</artifactId>
                  <version>3.8.1</version>
                  <configuration>
                      <!--根据个人需要自己修改-->
                      <source>9</source>
                      <target>9</target>
                  </configuration>
              </plugin>
          </plugins>
      </build>
  
  
  </project>

注解的事务:

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

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

    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>

    </bean>
    <!--配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!--基于xml配置spring事物的方式:
    开启事物的控制器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager
"></bean>
    <!--1开启支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    <!--2在需要的地方开启注解事物   @Transactional-->


</beans>

package com.itheima.service.Impl;

import com.itheima.dao.IAccountDao;
import com.itheima.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service("accountService")
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = false)
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;

    public static void main(String[] args) {

    }

}

3纯注解的方法,回顾:

op/spring-aop.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package=“com.itheima”></context:component-scan>

<!--配置JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>

</bean>
<!--配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
</bean>

<!--基于xml配置spring事物的方式:
开启事物的控制器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager

">

<tx:annotation-driven transaction-manager=“transactionManager”></tx:annotation-driven>






```java
package com.itheima.service.Impl;

import com.itheima.dao.IAccountDao;
import com.itheima.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service("accountService")
@Transactional(propagation = Propagation.NOT_SUPPORTED,readOnly = false)
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;

    public static void main(String[] args) {

    }

}