Spring IOC AOP练习

今天利用spring&mybatis，对账户进行CRUD操作，加深对spring IOC AOP以及与mybatis的整合。实现方法：ioc采用注解的方式配置，aop采用spring的接口来实现。
步骤：
**1、**利用命令行创建一个简单的sheet：mysql–>majinbuu1—>accountlist：

**2、**项目结构：

**3、**首先导入依赖：（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>Spring_demo1</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

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

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.2</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>

            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

其中，下面为AOP必须的依赖：（导入时，可能显示红色，这时idea窗口中有个小的刷新的图标，刷新下就可以导入了）

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

**4、**创建账户实体类：com.pht.POJO.Account。包含两个属性，两个构造方法（一个无参的），已经set get 方法，重写的tostring方法。

package com.pht.POJO;

public class Account {
    private String name;
    private int money;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }

    //无参构造器
    public Account() {
    }

    @Override
    public String toString() {
        return "Account{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

**5、**编写持久层接口，确定要实现的对数据库最基础的功能

package com.pht.Dao;

/**
 * 持久层接口，实现最基础的增删改查功能
 */

import com.pht.POJO.Account;

public interface InterDao {
    void addUser(Account user);
    void deleteUser(String name);
    Account queryUser(String name);
    Void updateUser(Account user);
}

**6、**配置连接mysql数据库的配置xml文件（文件名：mybatis-config.xml），并在idea中测试看是否连接成功。

<?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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/majinbuu1?serverTimezone=GMT"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/pht/Dao/mapper.xml"/>
    </mappers>
</configuration>

**7、**配置mapper文件：
（里面的中文注释只是方便查看，实际文件里面不能有中文注释），所有配置如下：

<?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.pht.Dao.InterDao">

    <select id="queryUser" resultType="com.pht.POJO.Account" parameterType="java.lang.String">
        select * from majinbuu1.accountlist where name=#{name}
    </select>

    <!--实体对象中的属性可以直接取出来，即下面的name，money-->
    <select id="addUser" parameterType="com.pht.POJO.Account">
        insert into majinbuu1.accountlist values (#{name},#{money})
    </select>

    <select id="deleteUser" parameterType="java.lang.String">
        delete from majinbuu1.accountlist where name=#{name}
    </select>

    <select id="updateUser" parameterType="com.pht.POJO.Account">
        update majinbuu1.accountlist set money=#{money} where name=#{name}
    </select>

</mapper>

**8、**编写一个工具类，解析mappe文件，并实现创建sqlseesion对象的功能：

package com.pht.Dao;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.io.InputStream;

public class daoUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        InputStream inputStream = null;
        try {
            String resource = "mybatis-config.xml";
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getsqlsession(){
        return sqlSessionFactory.openSession();
    }

}

**9、**利用工具类，实现持久层接口：

package com.pht.Dao;

import com.pht.POJO.Account;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

@Repository(value = "daoc")
public class impDao implements InterDao{
    //获取mysql的sqlseesion对象
    public static SqlSession ss= daoUtils.getsqlsession(); //为了在server层实现类中提交关闭sqlseesion，
    //因此，这里都设置为静态共有变量
    public static InterDao mysqlutil=ss.getMapper(InterDao.class);

    public void addUser(Account user) {
        mysqlutil.addUser(user);
    }

    public void deleteUser(String name) {
        mysqlutil.deleteUser(name);
    }

    public Account queryUser(String name) {
        return mysqlutil.queryUser(name);
    }

    public Void updateUser(Account user) {
        return mysqlutil.updateUser(user);
    }
}

**10、**业务层接口，对持久层接口中的方法进行打包加强，实现更具有业务逻辑的功能：

package com.pht.Server;

import com.pht.POJO.Account;

/**
 * 业务层接口，即为持久层接口的业务逻辑实现
 * 实现的功能为：
 *              1、增加一个用户，如果已经存在，则更新下它
 *              2、根据id，删除一个用户
 */
public interface InterSer {
    public void changeUser(Account user);
    public void removeUser(String name);
}

**11、**业务层实现类：

package com.pht.Server;

import com.pht.Dao.InterDao;
import com.pht.Dao.daoUtils;
import com.pht.Dao.impDao;
import com.pht.POJO.Account;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service(value = "serverc")
public class impSer implements InterSer{
    @Autowired
    //一般注入的数据都是不经常改变的
    private InterDao dao;
    SqlSession ssi=impDao.ss; //拿到dao中的SqlSession对象，以方便提交关闭事务

    public void changeUser(Account user) {
        String names=user.getName();
        Account acc=dao.queryUser(names);
        //如果存在，则更新；否则，添加
        if(acc==null){
            dao.addUser(user);
        }else{
            dao.updateUser(user);
        }
        ssi.commit();
        ssi.close(); //必须要关闭
    }

    public void removeUser(String name) {
        dao.deleteUser(name);
        //System.out.println("已删除！");
        ssi.commit();
        ssi.close();

    }
}

以上则实现了spring与mybatis的整合，并通过注解的方式，在spring容器中添加了一些bean，并进行了一些注入，实现了解耦。使用注解时，在sp.xml中添加：

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

即spring解析注解需要扫描的包

**12、**AOP的实现
切面：
首先编写log类，这里只实现简单的消息前置功能，继承spring的MethodBeforeAdvice接口，并重写before方法。

package com.pht.Log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Logs implements MethodBeforeAdvice {

    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("执行了"+o.getClass().getName()+"的"+method.getName()+"方法");
    }
}

**13、**完善sp.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
	
    <context:component-scan base-package="com.pht"/>
	<!--添加bean-->
    <bean id="serv" class="com.pht.Server.impSer"/>
    <bean id="log" class="com.pht.Log.Logs"/>
    <aop:config>
    	<!--切入点：即切面log类切入的位置-->
        <aop:pointcut id="pointcut" expression="execution(* com.pht.Server.impSer.*(..))"/>
        <!--执行切入，即在point处切入log-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

**14、**编写test文件进行测试：

package com.pht.test;

import com.pht.Dao.InterDao;
import com.pht.POJO.Account;
import com.pht.Server.InterSer;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Testdemo {
    ApplicationContext act = new ClassPathXmlApplicationContext("sp.xml");
    InterDao dao = (InterDao) act.getBean("daoc");
    InterSer ser=(InterSer) act.getBean("serverc");
    @Test
    public void test(){
        Account user=new Account("obama",400);
        ser.changeUser(user);
    }

    @Test
    public void test1(){
        ser.removeUser("kobi");
    }
}

**15、**测试结果：
可见，执行了aop切入的方法：


多次测试后，数据库都正确的实现了相应变化：