SpringJDBC数据库的基本使用

package Day03;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.commons.dbcp.BasicDataSource;

import Day01.DBUtilByDBCPInMac;

public class DBUtil {
        //数据库连接池
        private static BasicDataSource ds;
        //为不同线程管理连接
        private static ThreadLocal<Connection> tl;
        //不需要实例，只需要调用静态方法
        static {
            try {
                //创建properties
                Properties prop=new Properties();
                //获取文件输入流
                InputStream is=DBUtilByDBCPInMac.class.getClassLoader().getResourceAsStream("day01/config.properties");
                //加载文件输入流
                prop.load(is);
                is.close();
                //读取配置信息    
                //初始化连接池
                ds=new BasicDataSource();
                //设置驱动（Class.forName()）
                ds.setDriverClassName(prop.getProperty("driver"));
                //设置url
                ds.setUrl(prop.getProperty("url"));
                //设置数据库用户名
                ds.setUsername(prop.getProperty("user"));
                //设置数据库密码
                ds.setPassword(prop.getProperty("psw"));
                //设置初始连接数
                ds.setInitialSize(Integer.parseInt(prop.getProperty("initsize")));
                //设置最大连接数
                ds.setMaxActive(Integer.parseInt(prop.getProperty("maxactive")));
                //设置等待时间
                ds.setMaxWait(Integer.parseInt(prop.getProperty("maxwait")));
                //设置最小空闲数
                ds.setMinIdle(Integer.parseInt(prop.getProperty("minidle")));
                //设置最大连接数
                ds.setMaxIdle(Integer.parseInt(prop.getProperty("maxidle")));
                
                //初始化线程本地
                tl=new ThreadLocal<Connection>();
                
                
            }catch(Exception e) {
                e.printStackTrace();
            }
        }
        /**
         * 使用连接池获取连接
         * @return
         * @throws SQLException
         */
        public static Connection getConnection() throws SQLException {
            Connection conn=ds.getConnection();
            tl.set(conn);
            return conn;
        }
        /**
         * 关闭数据库连接
         */
        public static void closeConnection() {
            try {
            Connection conn=tl.get();
            if(conn!=null) {
                //恢复连接为自动提交事务
                conn.setAutoCommit(true);
                //关闭了连接
                conn.close();
                //但是连接池是不关闭连接的，为什么这里可以关闭？
                //因为这里关闭的只是连接池下连接的一个子类，关闭子类不影响连接池的连接
                //而是将连接归还
                tl.remove();
            }
            }catch(Exception e) {
                e.printStackTrace();
            }
            
        }
        
}

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import Entity.Employee;

/**
 * Spring JDBC的使用
 *
 */
@Repository("employeeDAO")
public class EmployeeDAO {
    //依赖注入jdbcTemplate
    @Resource(name="jt")//也可以用@Autowired和@Qualifier("jt")组合注解
    private JdbcTemplate jt;
    //把一个员工插入到数据库
    public void save(Employee e) {
        //只需要一条语句，完成自动创建连接，执行sql，关闭连接
        String sql ="INSERT INTO T_TABLE VALUES(2,?,?)";
        Object[] args= {e.getName(),e.getAge()};//元素的位置，跟上述sql一致
        jt.update(sql,args);
    }
    /**
     * 查询所有的员工
     * @return
     */
    //查询所有员工的方法
    public List<Employee> findAll(){
        String sql="SELECT * FROM T_TABLE";
        return jt.query(sql, new EmpRowMapper());
        
    }
    /**
     * 匿名内部类，这个类只能被当前类引用
     * @author
     *
     */
    class EmpRowMapper implements RowMapper<Employee>{
        /**
         * 告诉JDBCTemplate，如何将结果集转换成一个实体对象
         * rowNum：正在被处理的记录的下标，从0开始，为啥它好像在方法中就没用到过？
         */
        public Employee mapRow(ResultSet rs, int rowNum) throws SQLException {
            Employee e=new Employee();
            e.setId(rs.getInt("ID"));
            e.setName(rs.getString("NAME"));
            e.setAge(rs.getInt("age"));            
            return e;
        }
        
    }
    /**
     * 使用SpringJDBCTemplate进行查询
     * @param id
     * @return
     */
    public Employee findById(int id) {
        String sql="SELECT * FROM T_TABLE WHERE ID=?";
        Employee emp=null;
        try {
            Object[] object= {id};
            emp=jt.queryForObject(sql, object, new EmpRowMapper());
        }catch(EmptyResultDataAccessException e) {
            //空结果数据访问异常：没有数据查询到时会抛出此异常
            e.printStackTrace();
            return null;
        }
        return emp;
    }
    /**
     * SpringJDBC修改更新的方法
     * @param emp
     */
    public void modify(Employee emp) {
        String sql="UPDATE T_TABLE SET NAME=?,AGE=? WHERE ID=?";
        Object[] args= {emp.getName(),emp.getAge(),emp.getId()};
        jt.update(sql, args);
    }
    /**
     * SpringJDBC删除的方法
     * @param id
     */
    public void delete(int id) {
        String sql="DELETE FROM T_TABLE WHERE ID=?";
        Object[] args= {id};
        jt.update(sql, args);
    }
    

}

package Test;

import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import DAO.EmployeeDAO;
import Entity.Employee;

public class testCase {
    private EmployeeDAO dao;
    /**
     * @before注解修饰的作用是在其他测试方法运行之前会执行
     */
    @Before
    public void init() {
        String config="spring-jdbc.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(config);
        dao=ac.getBean("employeeDAO",EmployeeDAO.class);    
    }
    
    /**
     * 测试springJDBCTemplate
     */
    @Test
    public void test() {
        Employee e=new Employee();
        e.setName("duanyu");e.setAge(20);
        dao.save(e);
    }
    /**
     * 测试查询方法
     */
    @Test
    public void test1() {
        List<Employee> list=dao.findAll();
        System.out.println(list);
        
    }
    /**
     * 根据ID查询的测试
     */
    @Test
    public void test2() {
        Employee emp=dao.findById(2);
        System.out.println(emp);
        
    }
    /**
     * 更新ID为1的员工信息，UPDATE
     */
    @Test
    public void test3() {
        //先查到一个
        Employee employee=dao.findById(2);
        //对信息进行修改
        employee.setAge(employee.getAge()+10);
        dao.modify(employee);
        Employee newEmployee=dao.findById(2);
        System.out.println(newEmployee);
        
    }
    /**
     * 删除id为1的员工，方法测试
     */
    @Test
    public void test4() {
        dao.delete(2);
    }

}