//接口
public interface SomeService {
   void doSome();
}
//实现类
public class SomeServiceImpl implements SomeService {
    //无参构造
    public SomeServiceImpl() {
        System.out.println("SomeServiceImpl类的无参构造执行了...");
    }

    @Override 
    public void doSome() {
        System.out.println("执行了SomeServiceImpl的doSome()方法");
    }
}

//使用spring容器创建对象
    @Test
    public void test02() {
        //1、指定spring配置文件的名称
        String config = "beans.xml";
        //2、创建表示spring容器的对象 ApplicationContext
        //ClassPathXmlApplicationContext：表示从类路径中加载spring配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //3、从容器中获取对象
        SomeService service = (SomeService)ac.getBean("someService");
        //4、调用方法
        service.doSome();
    }

    /**
     * 测试spring容器创建对象的时机
     *  在创建spring容器时，会创建配置文件中的所有对象
     */

    @Test
    public void test03() {
        //1、指定spring配置文件路径
        String config = "beans.xml";
        //2、创建spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        /**
         * 测试输出结果：
         * SomeServiceImpl类的无参构造执行了...
         * SomeServiceImpl类的无参构造执行了...
         * 验证了spring调用类的无参构造完成对象的创建
         */
    }

    //获取spring容器中java对象的信息
    @Test
    public void test04() {
        String config = "beans.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //获取spring容器中对象的个数
        int beansCount = ac.getBeanDefinitionCount();
        System.out.println("spring容器中的对象个数="+beansCount);
        //获取spring容器中对象的名称（即bean标签的id值）
        String[] beansNames = ac.getBeanDefinitionNames();
        for (String beanName : beansNames) {
            System.out.println(beanName);
        }
    }

public class Student {
    private String name;
    private int age;
    private School school;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setSchool(School school) {
        this.school = school;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school=" + school +
                '}';
    }
}

<!--声明Student对象-->
    <bean id="student" class="com.mms.component.Student">
        <!--
            1、简单类型使用property和value标签给对象属性赋值
            2、简单类型：8个基本类型+String
            3、当spring容器加载到这一行时会在创建完对象的同时使用对象的set方法给属性赋值，底层
               调用的是对象的set方法
            4、spring容器调用的是setXxx()方法，而不管对象是否具有Xxx属性，Xxx不区分大小写
        -->
        <property name="name" value="张三"/>
        <property name="age" value="23"/>
        <!--测试对象没有属性的set方法-->
        <property name="graName" value="s1"/>
    </bean>

//引用类型属性
    private Address address;
    public void setAddress(Address address) {
        System.out.println("引用类型address的set方法执行了...");
        this.address = address;
    }

public class Address {

    private String homeAddress;
    private String schoolAddress;

    public void setHomeAddress(String homeAddress) {
        this.homeAddress = homeAddress;
    }

    public void setSchoolAddress(String schoolAddress) {
        this.schoolAddress = schoolAddress;
    }

    @Override
    public String toString() {
        return "Address{" +
                "homeAddress='" + homeAddress + '\'' +
                ", schoolAddress='" + schoolAddress + '\'' +
                '}';
    }
}

<!--声明Student对象-->
    <bean id="student" class="com.mms.component.Student">
        <property name="name" value="张三"/>
        <property name="age" value="23"/>
        <!--测试对象没有属性的set方法-->
        <property name="graName" value="s1"/>
        <!--
            引用类型属性的set注入
            property标签属性
                name：属性名
                ref：引用对象的id值
        -->
        <property name="address" ref="address"/>
    </bean>

    <!--Student对象的引用属性Address-->
    <bean id="address" class="com.mms.component.Address">
        <!--set注入-->
        <property name="homeAddress" value="新疆"/>
        <property name="schoolAddress" value="西安"/>
    </bean>

<!--
        构造注入
        1、使用constructor-arg标签完成构造注入
        2、构造注入方式一：根据形参名字
        3、构造注入方式二：根据形参顺序，默认下标从0开始递增
    -->

    <!--根据形参名构造注入，形参的出现顺序不是必须的-->
    <bean id="student" class="com.mms.value.Student">
        <constructor-arg name="name" value="李四"/>
        <constructor-arg name="age" value="24"/>
        <constructor-arg name="address" ref="address"/>
    </bean>
    <bean id="address" class="com.mms.value.Address">
        <constructor-arg name="homeAddress" value="新疆"/>
        <constructor-arg name="schoolAddress" value="西安"/>
    </bean>

    <!--构造注入，使用下标，出现的顺序没要求，因为已经通过下标绑定起来了-->
    <bean id="diByContructor" class="com.mms.value.Student">
        <constructor-arg index="0" value="赵六"/>
        <constructor-arg index="1" value="26"/>
        <constructor-arg index="2" ref="address"/>
    </bean>

<bean id="student" class="com.mms.ba03.Student" autowire="byName">
        <!--简单类型赋值-->
        <property name="name" value="张三"/>
        <property name="age" value="23"/>
    </bean>
    <!--引用类型-->
    <bean id="school" class="com.mms.ba03.School">
        <property name="schoolName" value="石河子大学"/>
        <property name="schoolAddress" value="石河子市"/>
    </bean>

<!--使用byType实现引用类型自动注入-->
    <bean id="student2" class="com.mms.ba03.Student" autowire="byType">
        <!--简单类型赋值-->
        <property name="name" value="李四"/>
        <property name="age" value="24"/>
    </bean>
    <!--引用类型
    <bean id="school2" class="com.mms.ba03.School">
        <property name="schoolName" value="西南大学"/>
        <property name="schoolAddress" value="重庆市"/>
    </bean>-->

    <!--声明School的子类-->
    <bean id="primarySchool" class="com.mms.ba03.PrimarySchool">
        <property name="schoolName" value="西北大学"/>
        <property name="schoolAddress" value="西安"/>
    </bean>

@Component(value = "student")
public class Student {
    ...
}

<bean id = "student" class = "com.mms.component.Student"/>

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

@Component("student")
public class Student {
    @Value("张三")
    private String name;
    @Value("23")
    private int age;
}

@Component("student")
public class Student {
    /*引用类型注入（byType方式）
    @Autowired
    private School school;*/

    //引用类型赋值（byName方式）
    @Autowired(required = false)
    @Qualifier(value = "mySchool")
    private School school;
}

@Component("mySchool")
public class School {

    //注入值
    @Value("西南大学")
    private String schoolAddress;
    @Value("新疆")
    private String homeAddress;

    @Override
    public String toString() {
        return "School{" +
                "schoolAddress='" + schoolAddress + '\'' +
                ", homeAddress='" + homeAddress + '\'' +
                '}';
    }
}

<!--aspectJ依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

public interface IService {
    void doSome(String name, int age);
}

public class ServiceImpl implements IService {
    @Override
    public void doSome(String name, int age) {
        System.out.println("===doSome()===");
    }
}

@Aspect
public class MyAspectJ {

    /**
     * 定义功能增强方法（方法就是切面）
     * 1、方法的必须为public
     * 2、方法无返回值
     * 3、方法名称自定义
     * 4、方法可以有参数，也可以没有参数
     * 5、方法的定义上方加入注解，表示切入点的执行时机

    @Before(value = "execution(public void com.mms.ba01.ServiceImpl.doSome(String,int))")
    public void beforeLog() {
        System.out.println("前置通知->系统当前时间：" + new Date());
    }
    */

    /*
        前置通知，带方法参数的切面
        切面方法有参数时要求参数是JoinPoint类型，参数名自定义，该参数就代表了连接点方法，即doSome方法
        使用该参数可以获取切入点表达式、切入点方法签名、目标对象等
     */
    @Before(value = "execution(* *..ServiceImpl.doSome(..))")
    public void beforeLog(JoinPoint jp) {
        System.out.println("连接点方法的方法签名="+jp.getSignature());
        System.out.println("连接点方法的方法名="+jp.getSignature().getName());
        //获取连接点方法参数
        Object[] args = jp.getArgs();
        for (Object arg : args) {
            System.out.println("arg="+arg);
        }
    }
}

public class MyTest {
    //aop前置通知
    @Test
    public void test01() {
        String config = "ba01/applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //获取目标对象，此时的service就是spring生成的代理对象
        //注意返回值类型是接口类型，不能是实现类接口，否则报错
        IService service = (IService) ac.getBean("service");
        //使用代理对象执行方法
        service.doSome("张三",23);
    }
}

Student doStudent(Student student);

@Override
    public Student doStudent(Student student) {
        return student;
    }

@Aspect
public class MyAspectJ {
    /**
     * @AfterReturning: 后置通知，在连接点方法执行之后执行后置通知方法
     * 方法定义格式：
     * 1、公共方法
     * 2、没有返回值
     * 3、方法名称自定义
     * 4、与前置通知一样，可以有JoinPoint类型参数，该参数表示连接点方法对象；还可以有一个
     *    Object类型参数，用于接收连接点方法的执行结果，注意该参数的参数名必须与切入点表达式
     *    的returning属性的属性值一致，表示将returning属性值赋给Object对象
     */
    /*@AfterReturning(value = "execution(* *..ServiceImpl.doOther(..))", returning = "obj")
        public void afterTransaction(JoinPoint jp, Object obj) {
        System.out.println("doOther方法的返回参数="+obj);
        System.out.println("事务已提交...");
        经过验证：在后置通知切面内不能改变连接点方法的返回值
    }*/

    @AfterReturning(value = "execution(* *..ServiceImpl.doStudent(..))", returning = "obj")
    public void afterTransaction(JoinPoint jp, Object obj) {
        System.out.println(obj);
        Student student = new Student();
        student.setName("李四");
        student.setAge(24);
        obj = student;
        System.out.println("===查看是否改变了连接点方法的返回值==="+obj);
        /*
            经过验证：在后置通知切面内不能改变连接点方法的返回值
         */
    }
}

@Aspect
public class MyAspectJ {

    /*
        环绕通知：@Around(切入点表达式)
        1、环绕通知是最重要的一个通知，他表示在连接点方法的前或者后都可以执行，它的本质就是jdk动态代理的invoke
           方法的method参数
        2、定义格式
            a、public
            b、必须有返回值，类型为Object

     */
    @Around(value = "pointCut()")

    /*
        再次回忆一下jdk动态代理的invoke方法的定义
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        是不是感觉与下面的方法定义眼熟啊，没错，环绕通知切面的定义实质上就是jdk动态代理
     */
    public Object around(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("环绕通知在连接点方法之前执行了...");
        Object result = null;
        result = pj.proceed();
        Student student = new Student();
        student.setName("李四");
        student.setAge(24);
        //改变连接点方法返回值
        result = student;
        System.out.println("事务已提交...");
        return result;
    }

    /*
        使用pointcut管理切面表达式
        1、在一个切面类中，若多个切面的切面表达式均为同一个，每次都要写重复的代码，此时就可以使用pointcut来
          管理切面表达式了
        2、定义格式：
            公共public
            无返回值
            无参数
     */
    @Pointcut(value = "execution(* *.doStudent(..))")
    public void pointCut() {
        //空方法体
    }
}

<dependencies>
    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--spring核心ioc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <!--mybatis和spring集成的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
    <!--阿里公司的数据库连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
  </dependencies>

  <build>
    <!--目的是把src/main/java目录中的xml文件包含到输出结果中。输出到classes目录中-->
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <!--指定jdk的版本-->
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>

实体类Student
public class Student {
    private int stuNo;
    private String stuName;
    private int cardID;
    private int classID;
    public Student() {
    }
    public Student(int stuNo, String stuName, int cardID, int classID) {
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.cardID = cardID;
        this.classID = classID;
    }
    public int getStuNo() {
        return stuNo;
    }
    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public int getCardID() {
        return cardID;
    }
    public void setCardID(int cardID) {
        this.cardID = cardID;
    }
    public int getClassID() {
        return classID;
    }
    public void setClassID(int classID) {
        this.classID = classID;
    }
    @Override
    public String toString() {
        return "Student{" +
                "stuNo=" + stuNo +
                ", stuName='" + stuName + '\'' +
                ", cardID=" + cardID +
                ", classID=" + classID +
                '}';
    }
}

public interface StudentMapper {
    //查询全部
    List<Student> queryAll();
    //新增学生
    void addStudent(Student student);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mms.mapper.StudentMapper">

    <!--查询全部-->
    <select id="queryAll" resultType="Student">
        select * from student
    </select>

    <!--新增学生-->
    <insert id="addStudent" parameterType="Student">
        insert into student (stuno,stuname,cardid,classid)
        values (#{stuNo},#{stuName},#{cardID},#{classID})
    </insert>
</mapper>

public interface IStudentService {
    List<Student> queryAll();
    void addStudent(Student student);
}

public class StudentServiceImpl implements IStudentService {
    //mapper属性
    private StudentMapper mapper;
    //set注入给mapper对象赋值
    public void setMapper(StudentMapper mapper) {
        this.mapper = mapper;
    }
    
    @Override
    public List<Student> queryAll() {
        return mapper.queryAll();
    }

    @Override
    public void addStudent(Student student) {
        mapper.addStudent(student);
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <!--
            批量设置别名，会自动的将该包下的所有类定义了别名，别名就是其自身且不区分大小
        -->
        <package name="com.mms.entity" />
    </typeAliases>
    <!--加载映射配置文件-->
    <mappers>
        <mapper resource="com/mms/mapper/studentMapper.xml"></mapper>
    </mappers>
</configuration>

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

    <!--加载数据库配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--声明数据源-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--set注入给数据库信息赋值，不需要指定驱动类，sprinf根据url自动识别
        <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf8&amp;useSSL=true&amp;serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="333"/>-->

        <!--使用db配置文件读取数据库信息，格式类似el表达式-->
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入赋值-->
        <!--set注入，把数据库连接池付给了dataSource属性-->
        <property name="dataSource" ref="myDataSource" />
        <!--mybatis主配置文件的位置
           configLocation属性是Resource类型，读取配置文件
           它的赋值，使用value，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis-config.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper（StudentDao.class）
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象。
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名， 包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行
            一次getMapper()方法，得到每个接口的dao对象。
            创建好的dao对象放入到spring的容器中的。 dao对象的默认名称是 接口名首字母小写
        -->
        <property name="basePackage" value="com.mms.mapper"/>
    </bean>

    <!--声明service-->
    <bean id="studentServiceImpl" class="com.mms.service.impl.StudentServiceImpl">
        <property name="mapper" ref="studentMapper"/>
    </bean>
</beans>

url = jdbc:mysql://localhost:3306/Xxx?characterEncoding=utf8&useSSL=true&serverTimezone=UTC
username = Xxx
password = Xxx

//执行查询全部，不使用service
    @Test
    public void test02() {
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //获取mapper的代理对象
        StudentMapper mapper = (StudentMapper) ac.getBean("studentMapper");
        List<Student> students = mapper.queryAll();
        for (Student student : students) {
            System.out.println("student--->"+student);
        }
    }

    //执行增加学生，使用service
    @Test
    public void test03() {
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //获取service对象
        IStudentService service = (IStudentService) ac.getBean("studentServiceImpl");
        Student student = new Student();
        student.setStuName("呵呵");
        student.setStuNo(1111);
        student.setCardID(1115);
        student.setClassID(1);
        service.addStudent(student);

    }

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

public void buy(Integer goodsId, Integer nums) {
        //sale表新增购买记录
        //更新库存
        //先查询该编号的商品是否存在
        Goods goods = goodsMapper.queryGoods(goodsId);
        //进行判断
        if (goods == null) {
            //说明商品不存在
        } else if (goods.getAmount() < nums) {
            //说明库存不足
        }
        //能够进行到这里说明商品信息是合法的，可以更新库存
    }

public class Goods {
    private Integer id;
    private String name;
    private Integer amount;
    private Float price;
    public Goods() {
    }
    public Goods(Integer id, String name, Integer amount, Float price) {
        this.id = id;
        this.name = name;
        this.amount = amount;
        this.price = price;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAmount() {
        return amount;
    }
    public void setAmount(Integer amount) {
        this.amount = amount;
    }
    public Float getPrice() {
        return price;
    }
    public void setPrice(Float price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Goods{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", amount=" + amount +
                ", price=" + price +
                '}';
    }
}
public class Sale {
    private Integer id;
    private Integer gid;
    private Integer nums;
    public Sale() {
    }
    public Sale(Integer id, Integer gid, Integer nums) {
        this.id = id;
        this.gid = gid;
        this.nums = nums;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getGid() {
        return gid;
    }
    public void setGid(Integer gid) {
        this.gid = gid;
    }
    public Integer getNums() {
        return nums;
    }
    public void setNums(Integer nums) {
        this.nums = nums;
    }
    @Override
    public String toString() {
        return "Sale{" +
                "id=" + id +
                ", gid=" + gid +
                ", nums=" + nums +
                '}';
    }
}

public interface GoodsMapper {
    /**
     * 更新库存
     * goods表示本次用户购买的商品信息
     * @param goods
     */
    void updateGoods(Goods goods);

    //查询商品信息
    Goods queryGoods(Integer id);
}
public interface SaleMapper {
    //增加销售记录
    void addSale(Sale sale);
}

<mapper namespace="com.mms.mapper.GoodsMapper">
    <!--更新商品信息-->
    <update id="updateGoods" parameterType="Goods">
        update goods set amount = amount - #{amount} where id = #{id}
    </update>
    <!--查询商品信息-->
    <select id="queryGoods" resultType="Goods">
        select * from goods where id = #{id}
    </select>
</mapper>
<mapper namespace="com.mms.mapper.SaleMapper">
    <!--增加销售记录-->
    <insert id="addSale" parameterType="Sale">
        insert into sale (gid,nums) values (#{gid},#{nums})
    </insert>
</mapper>

public interface IBuyGoodsService {
    //购买商品的方法，goodsId是购买商品的编号，nums是购买商品的数量
    void buy(Integer goodsId,Integer nums);
}

public class BuyGoodsServiceImpl implements IBuyGoodsService {

    private SaleMapper saleMapper;
    private GoodsMapper goodsMapper;
    //set注入赋值
    public void setSaleMapper(SaleMapper saleMapper) {
        this.saleMapper = saleMapper;
    }

    public void setGoodsMapper(GoodsMapper goodsMapper) {
        this.goodsMapper = goodsMapper;
    }


    /**
     * 购买商品方法
     * goodsId表示要购买的商品编号，nums表示购买的数量
     * @param goodsId
     * @param nums
     */

    /*
        1、@Transactional定义在需要加入事务处理的方法上面
        2、rollbackFor
            1）当方法发生的异常属于rollbackFor，事务就会回滚
            2）当方法发生的异常不属于rollbackFor，spring就会判断发生的异常是不是运行时异常，
               若是运行时异常，事务就会回滚

    @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                    NullPointerException.class,
                    NotEnoughException.class
            }

    )*/

    //开发中推荐使用默认值，直接使用@Transactional注解
    @Transactional
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("buy开始...");

        /*
            记录销售的信息，向sale表添加记录，由于sale表id是自增长的，所以不需要设置id属性
            向sale表添加一条购买记录
         */
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleMapper.addSale(sale);

        //更新库存
        //先查询该编号的商品是否存在
        Goods goods = goodsMapper.queryGoods(goodsId);
        //进行判断
        if (goods == null) {
            //说明商品不存在
            throw new NullPointerException("编号为:"+goodsId+"商品不存在...");
        } else if (goods.getAmount() < nums) {
            //说明库存不足
            throw new NotEnoughException("编号为:"+goodsId+"商品库存不足...");
        }

        //能够进行到这里说明商品信息是合法的，可以更新库存
        Goods good = new Goods();
        good.setId(goodsId);
        good.setAmount(nums);
        goodsMapper.updateGoods(good);

        System.out.println("buy结束...");
    }
}

<!--声明使用spring的事务处理-->
    <!--1、声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接的数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!--2、开启事务注解驱动，告诉sprint使用注解管理事务，创建代理对象-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

//不使用事务测试
    @Test
    public void test01() {
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //获取service对象
        IBuyGoodsService service = (IBuyGoodsService) ac.getBean("buyGoodsService");

        //商品编号不存在情况
        //java.lang.NullPointerException: 编号为:1003商品不存在...
        //service.buy(1003,50);
        //商品库存不足情况
        //com.mms.exception.NotEnoughException: 编号为:1002商品库存不足...
        //service.buy(1002,100);
        //正常情况
        service.buy(1002,10);
    }

<!--
       使用aspectj方式的事务（声明式事务）
       1、aspectj事务适合大型项目，因为其声明在配置文件中，大大与程序解耦合
    -->
    <!--1、声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    </bean>
    <!--
        2、声明业务方法的事务属性（隔离级别、传播行为、超时时间）
            id：自定义
            transaction-manager：事务故管理器对象的id值
    -->
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        <!--tx:attributes配置事务属性-->
        <tx:attributes>
            <!--
                tx:method：给具体的方法配置事务属性，method可以有多个，由于给多个方法配置事务
                name：方法名，不带包名和类名，方法可以使用通配符
                propagation：传播行为，枚举类
                isolation：隔离级别
                rollback-for：你指定的异常全限定类名，发生异常一定回滚
            -->
            <tx:method name="buy"
                       propagation="REQUIRED"
                       isolation="DEFAULT"
                       rollback-for="java.lang.NullPointerException,com.mms.exception.NotEnoughException"/>
        </tx:attributes>
    </tx:advice>
    
    <aop:config>
        <!--
        3、配置切入点表达式
        为什么需要配置切入点表达式？
            因为步骤2中的方法不确定是哪一个类、哪一个包的方法，所以需要指定
        -->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
        <!--
            配置增强器，用于关联advice和pointcut
            advice-ref：通知，上面的tx:advice的id值
            pointcut-ref：切入点表达式的id值
        -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    </aop:config>

public class User {
    private Integer id;  
	private String name;  
	private String password;  
	  
	public User(Integer id, String name, String password) {  
	    this.id = id;  
	    this.name = name;  
	    this.password = password;  
	}
    /* getters, setters, toString*/
}

public interface UserDao {
	/**  
	 * 添加  
	 */  
	int saveUser(User user);  
	  
	/**  
	 * 更新  
	 */  
	void updateUserById(User user);  
	  
	/**  
	 * 查询  
	 */  
	List<User> findAll();  
	  
	/**  
	 * 删除  
	 */  
	int deleteById(int id);
}

1. 扫描 mappper 配置文件 `SqlMapConfig.xml`
2. 创建 `SqlSessionFactoryBuilder` 工厂
3. 创建 `SqlSessionFactory` 工厂
4. 创建 `SqlSession`,包含 `CRUD` 方法
5. 获取 Mapper 接口的代理对象
6. 使用代理执行 CRUD 操作
7. 关闭资源

public void saveUserWithMap() {
	SqlSession session = MybatisUtil.getSqlSession();  
	UserDao ud = session.getMapper(UserDao.class);  
	// 构造map  
	Map<String, Object> map = new HashMap<>();  
	map.put("uname", "bbb");  
	map.put("uid", 2);  
	map.put("upwd", "5351");  
	// 执行sql  
	ud.saveUserWithMap(map);  
	session.commit();  
	// 7. 释放资源  
	session.close();
}

@Alias("hello")
public class User {
    private Integer id;  
	private String name;  
	private String password;  
	  
	public User(Integer id, String name, String password) {  
	    this.id = id;  
	    this.name = name;  
	    this.password = password;  
	}
    /* getters, setters, toString*/
}