spring学习二

1、spring进行aop操作

在spring里面进行aop操作，使用aspectj实现，可以用配置文件，也可以用注解；
注意：aspectj不是spring一部分，和spring一起使用进行aop操作，Spring2.0以后新增了对AspectJ支持
（1）导入jar包，除了前面的基本jar包之外，还要导入aop、aspects、aopalliance、aspectjweaver这些jar包；
在xml中引入下面的约束：

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

（2）基于xml配置的aop操作：
切入点：实际增强的方法
常用的表达式
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

（1）execution(* cn.melo.dao.UserDao.add(..))
（2）execution(* cn.melo.UserDao.*(..))
（3）execution(* *.*(..))
（4） 匹配所有save开头的方法 execution(* save*(..))

假设对service层的UserService的add方法进行一个前置增强：
A、写类：
UserDao.java：

package cn.melo.dao;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

@Repository(value = "userDao")
public class UserDao {
    public void add(){
        System.out.println("add............");
    }
}

UserService.java

package cn.melo.service;

import cn.melo.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service(value = "userService")
public class UserService {
    @Autowired
    private UserDao userDao;
    public void add(){
        userDao.add();
    }
}

增强类（LoggerAspect.java）：

package cn.melo.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.stereotype.Component;
@Component(value = "loggerAspect")
public class LoggerAspect {

    
    //这个方法用于测试前置增强
    public void log1(){
        System.out.println("前置增强");
    }

    //这个方法用来测试后置增强
    public void log2(){
        System.out.println("后置增强");
    }
    //这个方法用于测试环绕增强
    public void log(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("方法执行前:" + joinPoint.getSignature().getName());
        //调用这个方法会执行，你要增强的方法
        joinPoint.proceed();
        System.out.println("方法执行后:" + joinPoint.getSignature().getName());
    }
}

B、配置aop操作：

 <!--配置aop操作-->
    <aop:config>
        <!--配置切入点，表示对UserService类中的所有方法进行增强-->
        <aop:pointcut id="pointcut1" expression="execution(* cn.melo.service.UserService.*(..))"/>
        <!--配置切面，把增强用到方法上，表示用哪个类的那个方法去增强，ref是增强类的bean的id-->
        <aop:aspect ref="loggerAspect">
        	<!--aop:before表示前置增强，在切入点执行之前，先执行我们配置的方法-->
            <aop:before pointcut-ref="pointcut1" method="log1"/>
        </aop:aspect>
    </aop:config>

C、测试：
测试代码：

@org.junit.Test
public void test2(){
    ApplicationContext context = new
            ClassPathXmlApplicationContext("beans.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

执行结果：

D、测试后置增强：
配置：

<!--配置aop操作-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pointcut1" expression="execution(* cn.melo.service.UserService.*(..))"/>
    <aop:aspect ref="loggerAspect">
        <aop:after pointcut-ref="pointcut1" method="log2"/>
    </aop:aspect>
</aop:config>

测试代码不变，测试结果：

配置环绕增强：

<!--配置aop操作-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pointcut1" expression="execution(* cn.melo.service.UserService.*(..))"/>
    <!--配置切面，把增强用到方法上-->
    <aop:aspect ref="loggerAspect">
        <aop:around pointcut-ref="pointcut1" method="log"/>
    </aop:aspect>
</aop:config>

测试代码不变，测试结果：

（3）基于注解配置的aop操作：
A、首先在spring核心配置文件中，开启aop操作：

<!--开启aop操作-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

B、然后在增强类上写上注解：@Aspect，在增强方法上写@Before(value=“xx”)或者@After(value=“xx”)等，value的值就是execution表达式；

2、spring的jdbcTemplate操作：

（1）spring对不同的持久化层技术都进行了封装：
jdbc：org.springframework.jdbc.core.JdbcTemplate
hibernate5：org.springframework.hibernate5.HibernateTemplate
ibatis：org.springframework.ibatis.SqlMapClientTemplate
jpa：org.springframework.jpa.JpaTemplate
（2）spring的JDBCTemlate的操作：
A、导入jar包，除了基本包以外还要导入spring的jdbc和tx的jar包，当然还要数据库驱动jar包！
B、写xml配置文件：

<!--创建DriverManagerDataSource对象-->
 <bean id="dmds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
     <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
     <property name="url" value="jdbc:mysql:///mydb?serverTimezone=GMT%2b8&amp;characterEncoding=utf8">
     </property>
     <property name="username" value="root"></property>
     <property name="password" value="123"></property>
 </bean>
 <!--创建JdbcTemplate对象-->
 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
     <constructor-arg name="dataSource" ref="dmds"></constructor-arg>
 </bean>

C、写测试代码：
添加操作：

@Test
public void insert(){
    //加载配置文件得到两个对象
    ApplicationContext context = new
              ClassPathXmlApplicationContext("beans.xml");
    DriverManagerDataSource dmds = context.getBean("dmds",DriverManagerDataSource.class);

    //获得JdbcTemplate对象
    JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate",JdbcTemplate.class);
    //sql语句
    String sql = "insert into user values(?,?,?)";
    //添加操作,返回影响行数
    int rows = jdbcTemplate.update(sql,4,"james","xxx");
    System.out.println(rows);

}

测试结果：

删除操作：

//sql语句
String sql = "delete from user where id=?";
//删除操作,返回影响行数
int rows = jdbcTemplate.update(sql,4);
System.out.println(rows);

修改操作：

//sql语句
String sql = "update user set username=? where id=?";
//修改操作,返回影响行数
int rows = jdbcTemplate.update(sql,"何建谋",3);
System.out.println(rows);

查询操作一：查询某个对象（一条记录）：

@Test
public void select1(){
    //加载配置文件得到两个对象
    ApplicationContext context = new
             ClassPathXmlApplicationContext("beans.xml");
     DriverManagerDataSource dmds = context.getBean("dmds",DriverManagerDataSource.class);

     //获得JdbcTemplate对象
    JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate",JdbcTemplate.class);
    //sql语句
    String sql = "select * from `user` where id = ?";
    //查询操作
   jdbcTemplate.queryForObject(sql, new RowMapper<User>() {
        @Override
        public User mapRow(ResultSet resultSet, int i) throws SQLException {
            User user = new User();
            Integer id = resultSet.getInt(1);
            String username = resultSet.getString(2);
            String password = resultSet.getString(3);
            user.setId(id);
            user.setUsername(username);
            user.setPassword(password);
            System.out.println(user);
            return user;
        }
    },1);

}

结果：

查询操作一：查询一个集合（多条记录）：

@Test
public void select2(){
   //加载配置文件得到两个对象
    ApplicationContext context = new
            ClassPathXmlApplicationContext("beans.xml");
    DriverManagerDataSource dmds = context.getBean("dmds",DriverManagerDataSource.class);

    //获得JdbcTemplate对象
    JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate",JdbcTemplate.class);
    //sql语句
    String sql = "select * from `user`";
    //查询操作
    jdbcTemplate.query(sql, new RowMapper<List<User>>() {
        @Override
        public List<User> mapRow(ResultSet resultSet, int i) throws SQLException {
            List<User> list = new ArrayList<>();
            while(resultSet.next()){
                int id = resultSet.getInt(1);
                String username = resultSet.getString(2);
                String password = resultSet.getString(3);

                User user = new User(id,username,password);
                list.add(user);
            }
            System.out.println(list);
            return list;
        }
    });

}

结果：

查询操作三（查询记录数等）
代码：

@Test
public void select3(){
    //加载配置文件得到两个对象
    ApplicationContext context = new
            ClassPathXmlApplicationContext("beans.xml");
    DriverManagerDataSource dmds = context.getBean("dmds",DriverManagerDataSource.class);

    //获得JdbcTemplate对象
    JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate",JdbcTemplate.class);
    //sql语句
    String sql = "select count(*) from `user`";
    //查询操作
    long count = jdbcTemplate.queryForObject(sql,Long.class);
    System.out.println(count);

}

结果：

3、spring中配置连接池（Druid）

（1）配置文件：

<!--配置druid连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql:///mydb?serverTimezone=GMT%2b8&amp;characterEncoding=utf8">
    </property>
    <property name="username" value="root"></property>
    <property name="password" value="123"></property>
</bean>

（2）测试代码：

@Test
public void testDBPool() throws SQLException {
    //加载配置文件得到对象
    ApplicationContext context = new
            ClassPathXmlApplicationContext("beans.xml");
    DruidDataSource dataSource = context.getBean("dataSource",DruidDataSource.class);
    Connection conn = dataSource.getConnection();
    System.out.println(conn);
}

结果：

其实spring针对不同的dao层框架都提供了不同的实现类：
springJdbc和ibatis：DataSourceTransactionManager
hiberntae5.0：HibernateTransactionManager
可以在这些实现类中注入datasource即可使用连接池！