Day57-JdbcTemplate

Posted 2021-05-25 五条人

加油，加油，加油~！！！！

Day57_ JdbcTemplate

 

JdbcTemplate

1.引入jar包

2.连接数据库，在xml文件中配置数据库连接

<bean id ="dataSource" class ="com.alibaba.druid.pool.DruidSource" destroy-method ="close">
    <property name ="url" value = "jdbc:mysql:///user_db"/>
    <property name ="username" value ="root"/>
    <property name ="password" value ="123456"/>
    <property name ="driverClassName" value ="com.mysql.jdbc.Driver"/>
</bean>

3.配置JdbcTemplate对象，注入DataSource

<bean id ="jdbcTemplate" class ="org.springframework.jdbc.core.JdbcTemplate">
    <property id = "dataSource" ref ="dataSource"></property>
</bean>

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

public interface BookDao(){
   
    public void addBook(Book book){}
}
​
public class BookDaoImpl implements BookDao(){
    
    //注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    public void add(Book book){
        String sql ="insert into t_book values(?,?,?)";
        int upadte = jdbcTemplate.add(sql,book.getUserID,book.getUsername,book.getUstatus());
    }
}
​
​
public class BookService(){
    
    //注入dao
    @Autowired
    private BookDao bookdao;
    
    public void addBook(Book book){
        
        bookDao.add(book)
    }
    
}

5.组件扫描。

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

 

删除，修改

//修改功能
@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.updae(sql,args);
}
​
//删除功能
@Override
public void deleteBook(String id){
    
    String sql ="delete t_book where user_id =?";
    
    int update = jdbcTemplate.update(sql,id);
    
}

 

JdbcTemplate 操作数据库（查询返回某个值）

1、查询表里面有多少条记录，返回是某个值

2、使用 JdbcTemplate 实现查询返回某个值代码

具体步骤：

1.先去BookDao创建方法

int selectCount();

2.去BookService里面调用BookDao创建的方法

public int findCount(){
    return bookDao.selectCount();
}

3.去BookDaoImpl里面写sql语句，实现功能（重写BookDao中的selectCount（）方法。）

这里的queryForObject（）方法里面有两个参数，一个是String sql，一个是Class<T> requiredType

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

 

JdbcTemplate 操作数据库（查询返回对象）

1、场景：查询图书详情

2、JdbcTemplate 实现查询返回对象

具体步骤：

1.在BookDao中

Book findBookInfo(String id);

2.在BookService中

public Book findOne(String id){
    return bookDao.findBookInfo(id);
}

3.在BookDaoImpl中

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;
}

 

JdbcTemplate 操作数据库（查询返回集合）

1、场景：查询图书列表分页… 2、调用 JdbcTemplate 方法实现查询返回集合

具体步骤：

1.在BookDao中

List<Book> findAllBook();

2.在BookService中

public List<Book> findAll(){
    return bookDao.findAllBook();
}

3.在BookDaoImpl中

@Override
public List<Book> findAllBook(){
    String sql ="select * from t_book";
    //这里没带参数，所以就可以省略了，和上面查询单个对象差不多。
    List bookList = jdbcTemplate.query(sql,new BeanPropertyRowMapper<Book>(Book.class));
    return bookList;
}

 

JdbcTemplate 操作数据库（批量添加）

jdbcTemplate 实现批量添加操作

具体步骤：

1.在BookDao（）中

void batchAddBook(List<Object> batchArgs);

2.在BookService（）中

public List<Object[]> batchAdd(List<Object> batchArgs){
    bookDao.batchAddBook();
}

3.在BookDaoImpl中

@Override
public List<Object[]> batchAddBook(List<Object> batchArgs){
    String sql = "insert into t_book values(?,?,?)";
    int[] ints =jdbcTemplate.batchUpdate(sql,batchArgs);
    //将ints数组toString出来。
    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);

 

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));
}
//批量修改
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"java0909","a3","3"};
Object[] o2 = {"c++1010","b4","4"};
Object[] o3 = {"MySQL1111","c5","5"};
batchArgs.add(o1);
batchArgs.add(o2);
batchArgs.add(o3);
//调用方法实现批量修改
bookService.batchUpdate(batchArgs);
​

JdbcTemplate 实现批量删除操作

//批量删除
@Override
public void batchDeleteBook(List<Object[]> batchArgs) {
    String sql = "delete from t_book where user_id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}
//批量删除
List<Object[]> batchArgs = new ArrayList<>();
Object[] o1 = {"3"};
Object[] o2 = {"4"};
batchArgs.add(o1);
batchArgs.add(o2);
//调用方法实现批量删除
bookService.batchDelete(batchArgs)

 

事务操作

事务概念

1、什么事务 （1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操 作都失败 （2）典型场景：银行转账

lucy 转账 100 元 给 mary

lucy 少 100，mary 多 100

2、事务四个特性（ACID） （1）原子性：不可分割，一个失败都失败 （2）一致性：操作之前和操作之后，总量是不变的。 （3）隔离性：多事务操作的时候，是不会产生影响的。 （4）持久性：当事务最终提交后，表中数据真正发生变化。

 

事务操作（搭建事务操作环境）

 

正常的事务的流程：（编程式事务管理）。

try{
    //第一步，开启事务
    
    //第二部，事务操作
    
    //第三步，没有异常，事务提交。
​
}catch(Exception e){
    //第四步，有异常，事务回滚。
    e.printStackTrace();
}

 

事务操作（Spring 事务管理介绍）

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

2、在 Spring 进行事务管理操作

（1）有两种方式：编程式事务管理（不使用，基本。）和声明式事务管理（使用）

3、声明式事务管理

（1）基于注解方式（基本使用这个）

（2）基于 xml 配置文件方式

4、在 Spring 进行声明式事务管理，底层使用 AOP 原理

5、Spring 事务管理 API

（1）提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

 

事务操作（注解声明式事务管理）

1.在 spring 配置文件配置事务管理器

<!--创建事务管理器-->
<bean id ="transactionManager" class ="org.springframework.jdbc.dataSource.DataSourTransactionManager">
    <!--注入数据源 -->
    <property name="dataSource" ref ="dataSource"></property>
</bean>

2.在 spring 配置文件配置事务管理器

<!--在Spring配置文件中引入空间名称tx-->
<bean xmlns: tx =" http://www.springframework.org/schema/tx"
​
    xsi:schemaLocation ="http://www.springframework.org/schema/tx
                    http://www.springframework.org/schema/tx/spring-tx.xsd">
</bean>

<!-- 开启事务注解-->
<tx:annotation-driven transaction-manager = "transactionManager"></tx:annotation-driven>

3.在 service 类上面（或者 service 类里面方法上面）添加事务注解

1.@Transactional，这个注解添加到类上面，也可以添加方法上面

2.假如在类上面加@Transactional ，就是对类中所有方法加上事务。

3.假如在类中的某些方法上面加@Transactional，就是仅对这些方法加上事务。

 

事务操作（声明式事务管理参数配置）

在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数

 

1、propagation：事务传播行为

概念：多事务方法之间进行调用，这个过程中事务是如何进行管理的

事务方法：对数据库表数据进行变化的操作（增、删、改的行为）。（至少有两个方法）

在add（）方法里面调用update（）方法，这个过程叫做事务传播行为。

@Transactional （propagation = Propagation .REQUIRED)

两种典型情况：

2、ioslation：事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

（2）有三个读问题：脏读、不可重复读、虚（幻）读

（3）脏读：一个未提交事务读取到另一个未提交事务的数据

（4）不可重复读：一个未提交事务读取到另一提交事务修改数据

（5）虚读：一个未提交事务读取到另一提交事务添加数据

（6）解决：通过设置事务隔离级别，解决读问题

 

3、timeout：超时时间

（1）事务需要在一定时间内进行提交，如果不提交进行回滚

（2）默认值是 -1 ，设置时间以秒单位进行计算

 

4、readOnly：是否只读 （1）读：查询操作，写：添加修改删除操作

（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作

（3）设置 readOnly 值是 true，设置成 true 之后，只能查询

 

5、rollbackFor：回滚

（1）设置出现哪些异常进行事务回滚

6、noRollbackFor：不回滚

（1）设置出现哪些异常不进行事务回滚

 

事务操作（XML 声明式事务管理）

1、在 spring 配置文件中进行配置 第一步 配置事务管理器

第二步 配置通知

第三步 配置切入点和切面

<?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"
       xmlns:tx="http://www.springframework.org/schema/tx"
​
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop  http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx.xsd">
​
    <!--组件扫描 -->
    <context:component-scan base-package="com.sorrymaker"></context:component-scan>
​
    <!-- 数据库连接池 -->
    <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="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
​
    <!-- JdbcTemplate对象 -->
    <bean id=" jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
​
    <!--1.创建事务管理器 -->
    <bean id ="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 注入数据源-->
        <property name="dataSource" ref ="dataSource"></property>
    </bean>
    <!--2. 配置通知-->
    <tx:advice id ="txadvice">
        <!--配置事务参数 -->
        <tx:attributes>
            <!--规定哪些方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!-- 3.配置切入点和切面-->
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* com.sorrymaker.spring5.service.UserService.*(..))"/>
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>
</beans>

 

 

---

算法题

反转字符串

1.用api做。

return new StringBuilder（str）.reverse（）.toString（）

2.用脑子来做

public class test(){
    public String cool(String str){
        int j=0;
        char[] chars = str.toCharArray();
        char[] st = new char[chars.length];
        for(i=chars.length-1;i>=0;i--){
            st[j++]=chars[i];
        }
        return String.valueOf(st);
    }
}