（四）Spring学习笔记（AOP和JdbcTemplate）

AOP操作（AspectJ注解）

1.创建类，在类里面定义方法

public class User {
    public void add(){
        System.out.println("add...");
    }
}

2.创建增强类（编写增强逻辑）

（1）在增强类里面，创建方法，让不同方法代表不同的通知类型

// 增强类
public class UserProxy {
    // 前置通知
    public void before(){
        System.out.println("before...");
    }
}

3.进行通知的配置

（1）在spring配置文件中，开启注解扫描

（2）使用注解创建User和UserProxy

（3）在增强类上面添加注解@Aspect

// 增强类
@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 前置通知
    public void before(){
        System.out.println("before...");
    }
}

（4）在spring配置文件中开启生成代理对象

    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy/>

4.配置不同类型的通知

（1）在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置。

// 增强类
@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 前置通知
    // Before注解作为前置通知
    @Before(value = "execution(* com.demo..aopanno.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
}

 @AfterReturning(value = "execution(* com.demo.aopanno.User.add(..))")
    public void AfterReturning(){
        System.out.println("AfterReturning......");
    }

    @After(value = "execution(* com.demo.aopanno.User.add(..))")
    public void after(){
        System.out.println("after......");
    }

    @AfterThrowing(value = "execution(* com.demo.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrongwing......");
    }

    @Around(value = "execution(* com.demo.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前");

        // 被增强的方法执行
        ProceedingJoinPoint.proceed();

        System.out.println("环绕之后");
    }

5.公共切入点抽取

    @Pointcut(value = "execution(* com.demo.aopanno.User.add(..))")
    public void pointdemo(){
        
    }

6.有多个增强类对一个类进行增强，设置优先级

（1）在增强类上面添加注解@Order(数字类型值)，数字越小优先级越高

AOP操作（AspectJ配置文件）

1.创建两个类，增强类和被增强类，创建方法

2.在spring配置文件中创建两个对象

3.在spring配置文件中配置切入点

7.完全使用注解开发

创建配置类，不需要创建xml配置文件

@Configuration
@ComponentScan(basePackages = {})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop{
  
}

JdbcTemplate（概念和准备）

1.什么是JdbcTemplate

（1）Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作

2.准备工作

（1）引入相关jar包

Spring-jdbc-5.2.6.REALEASE.jar

Spring-orm-5.2.6.REALEASE.jar

Spring-tx-5.2.6.REALEASE.jar

（2）在spring配置文件配置连接池

    <!--数据库连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql://user_db"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>

(3)配置JdbcTemplate对象，注入DataSource

    <!--JdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

(4)创建service类，创建dao类，在dao中注入jdbcTemplate对象

开启组建扫描

    <!--组件扫描-->
    <context:component-scan base-package="com.demo"/>

service

@Service
public class Book {
    //注入dao
    @Autowired
    private BookDao bookDao;
}

dao

@Repository
public class BookDaoImpl implements BookDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

JdbcTemplate操作数据库

1.对应数据库表创建出实体类

2.编写service和doa

(1)在dao进行数据库添加操作

（2）调用JdbcTemplate对象里面update方法实现添加操作

有两个参数
第一个参数：sql语句
第二个参数：可变参数，设置sql语句值

JdbcTemplate操作数据库（修改和删除）

1.修改

@Override
public void updateBook(Book book){
  String sql = "update t_book set username=?,ustatus=?where user id=?";
  Object[] args = {book.getUsername(),book.getUstatus(),book.getUserId()};
  int update = jdbcTemplate.update(sql,args);
  System.out.println(update);
}

2.删除

@Override
public void delete(String id){
  String sql = "delete from t_book where user id=?";
  int update = jdbcTemplate.update(sql, id);
  System.out.println(update);
  
}

3.查询(查询返回某个值)

（1）查询表里有多少数据，使用JdbcTemplate实现查询返回某个值代码

@Override
public int selectCount(){
  String sql = "select count(*) from t_book";
  Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
  return count;
}

（2）查询返回对象

@Override
public Book findBookInfo(String id){
  String sql = "select * from t_book where user id=?";
  Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
  return book;
}

有三个参数

第一个参数：sql语句

第二个参数：RowMapper，是接口，返回不同类型的数据，使用这个接口里面实现类，完成数据的封装。

第三个参数：sql语句值

（3）查询返回集合

总结：增删改用update()，查单个返回值用queryForObject()，查多个返回值的用query()

批量操作：

1.操作表里多条记录

2.JdbcTemplate实现批量添加操作

有两个参数

第一个参数：sql语句

第二个参数：List集合，添加多条记录数据

@Override
public void batchAddBook(List<Object[]> batchArgs){
  String sql = "insert into t_book values(?,?,?)";
  int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
  System.out.println(Arrays.toString(ints));
}
// 批量添加测试
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3", "java", "a"};
Object[] o2 = {"4", "c++", "b"};
Object[] o3 = {"5", "MySQL", "c"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
// 调用批量添加
bookService.batchAdd(batchArgs);

3.JdbcTemplate实现批量修改操作

@Override
public void batchUpdateBook(List<Object[]> batchArgs){
  String sql = "update t_book set username=?,ustatus=? where user_id=?";
  int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
  System.out.println(Arrays.toString(ints));
}

4.JdbcTemplate实现批量删除操作

@Override
public void batchDeleteBook(List<Object[]> batchArgs){
  String sql = "delete from t_book where user_id=?";
  int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
}

（四）Spring学习笔记（AOP和JdbcTemplate）

JdbcTemplate（概念和准备）

猜你喜欢