Base de données des opérations SpringTemplate (comprendre)

I. Aperçu

Afin de rendre JDBC plus facile à utiliser, Spring définit une couche d'abstraction sur l'API JDBC pour établir un cadre d'accès JDBC.

En tant que noyau du framework Spring JDBC, le modèle JDBC est conçu pour fournir des méthodes de modèle pour différents types d'opérations JDBC. De cette manière, la charge de travail de l'accès à la base de données peut être minimisée tout en conservant autant que possible la flexibilité.

Vous pouvez considérer le JdbcTemplate de Spring comme un petit cadre de couche de persistance léger, qui est très proche du style DBUtils que nous avons utilisé auparavant.

2. Préparation de l'environnement

2.1 Importer le package JAR

1. Package JAR requis par le conteneur IOC

    commons-logging-1.1.1.jar
    spring-beans-4.0.0.RELEASE.jar
    spring-context-4.0.0.RELEASE.jar
    spring-core-4.0.0.RELEASE.jar
    spring-expression-4.0.0.RELEASE.jar
   

2. Package JAR requis par JdbcTemplate

    spring-jdbc-4.0.0.RELEASE.jar
    spring-orm-4.0.0.RELEASE.jar
    spring-tx-4.0.0.RELEASE.jar
   

3. Pilote de base de données et source de données

    druid-1.1.9.jar
    mysql-connector-java-5.1.7-bin.jar
   

2.2 Configurer les beans associés dans le fichier de configuration Spring

Configurer l'objet de source de données et l'objet JdbcTemplate

<!-- 引入外部配置文件,注意classpath严格区分大小写 -->
<context:property-placeholder location="classpath:dbconfig.properties"/>

<!--
	测试数据源 
	${}取出配置文件中的值
	#{}Spring的表达式语言
-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="user" value="${jdbc.user}"></property>
	<property name="password" value="${jdbc.password}"></property>
	<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
	<property name="driverClass" value="${jdbc.driverClass}"></property>
</bean>

<!-- Spring提供了一个类JdbcTemplate，我们用它操作数据库；
	导入Spring的数据库模块
		spring-jdbc-4.0.0.RELEASE.jar
		spring-orm-4.0.0.RELEASE.jar
		spring-tx-4.0.0.RELEASE.jar
	 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
</bean>

Troisièmement, opération d'endurance

3.1 Ajouts, suppressions et modifications

JdbcTemplate.update(sql, Object...)

Exemple:

//将emp_id=5的记录的salary字段更新为1300.00
@Test
public void test02(){
    
    
	System.out.println(jdbcTemplate);
	String sql = "update employee set salary=?  where emp_id=?";
	int update = jdbcTemplate.update(sql, 1300.00,5);
	System.out.println(update);
}

3.2 Ajout, suppression et modification par lots

JdbcTemplate.batchUpdate(sql, List<Object[]>)
	Object[]封装了SQL语句每一次执行时所需要的参数
	List集合封装了SQL语句多次执行时的所有参数

/**
 * 批量插入
 */
@Test
public void test03(){
    
    
	String sql = "insert into employee(emp_name,salary) values(?,?)";
	//List<Object[]>
	//List的长度就是sql语句要执行的次数
	//Object[]：每次执行要用的参数
	List<Object[]> batchArgs = new ArrayList<Object[]>();
	batchArgs.add(new Object[]{
    
    "Jack1",1241.0});
	batchArgs.add(new Object[]{
    
    "Jack2",1242.0});
	batchArgs.add(new Object[]{
    
    "Jack3",1243.0});
	batchArgs.add(new Object[]{
    
    "Jack4",1244.0});
	int[] batchUpdate = jdbcTemplate.batchUpdate(sql, batchArgs);
	for(int i : batchUpdate){
    
    
		System.out.println(i);
	}
}

3.3 Interroger une seule ligne

JdbcTemplate.queryForObject(sql, RowMapper<Department>, Object...)

/**
 * 实验4：查询emp_id=5的数据库记录，封装为一个Java对象返回；
 * javaBean需要和数据库中字段名一致，否则无法完成封装；
 * 
 * jdbcTemplate在方法级别进行了区分
 * 查询集合：jdbcTemplate.query()
 * 查询单个对象：jdbcTemplate.queryForObject()
 * 		如果查询没结果就报错；（无法自动赋值为null）
 * 
 */
@Test
public void test04(){
    
    
	String sql = "select emp_id empId,emp_name empName,salary from employee where emp_id=?";
	Employee queryForObject = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<>(Employee.class),5);
	System.out.println(queryForObject);
}

3.4 Interroger plusieurs lignes

JdbcTemplate.query(sql, RowMapper<Department>, Object...)
RowMapper对象依然可以使用BeanPropertyRowMapper

/**
 * 实验5：查询salary>4000的数据库记录，封装为List集合返回
 */
@Test
public void test05(){
    
    
	String sql2 = "select emp_id empId,emp_name empName,salary from employee where salary>?";
	List<Employee> query = jdbcTemplate.query(sql2, new BeanPropertyRowMapper<>(Employee.class), 4000);
	System.out.println(query);
}

3.5 Interroger une valeur unique

JdbcTemplate.queryForObject(sql, Class, Object...)
如果返回值类型为jdk中已有的类，则传入class类型

/**
 * 查询最大的salary
 */
@Test
public void test06(){
    
    
	String sql = "select max(salary) from employee";
	Double queryForObject = jdbcTemplate.queryForObject(sql,Double.class);
	System.out.println(queryForObject);
}

Quatre, utilisez le JdbcTemplate avec des paramètres nommés

4.1 À propos des paramètres nommés

• Dans la requête HQL d'Hibernate, nous avons expérimenté l'utilisation de paramètres nommés. Par rapport aux paramètres basés sur la position, les paramètres nommés ont une meilleure maintenabilité. Vous pouvez envisager d'utiliser des paramètres nommés lorsqu'il y a plus de paramètres dans l'instruction SQL.
• Dans Spring, les instructions SQL avec des paramètres nommés peuvent être utilisées via des objets de la classe NamedParameterJdbcTemplate.

4.2 Créer un objet NamedParameterJdbcTemplate via le conteneur IOC

<!-- 配置可以使用具名参数的JDBCTemplate类对象 -->
<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
	<!-- 没有无参构造器，必须传入数据源或JdbcTemplate对象 -->
	<constructor-arg ref="dataSource"/>
</bean>

4.3 Le format des paramètres nommés dans les instructions SQL

INSERT INTO depts (dept_name) VALUES (:deptName)

4.4 Passer des paramètres nommés

1. Passé via l'objet Map

   /**
    * 实验7：使用带有具名参数的SQL语句插入一条员工记录，并以Map形式传入参数值
    * 
    * 具名参数：（具有名字的参数，参数不是占位符了，而是一个变量名）
    * 		语法格式：   :参数名
    * Spring有一个支持具名参数功能的JdbcTemplate——NamedParameterJdbcTemplate
    * 
    */
   @Test
   public void test07(){
         
         
   	String sql = "insert into employee(emp_name,salary) values(:empName,:salary)";
   	Map<String,Object> paramMap = new HashMap<>();
   	//将所有具名参数的值都放在map中；
   	paramMap.put("empName","zhangsan");
   	paramMap.put("salary",309);
   	int update = namedParameterJdbcTemplate.update(sql, paramMap);
   	System.out.println(update);
   }
   

2. Transmis via l'objet SqlParameterSource
   

   /**
    * 使用带有具名参数的SQL语句插入一条员工记录，以SqlParameterSource形式传入参数值
    */
   @Test
   public void test08(){
         
         
   	String sql = "insert into employee(emp_name,salary) values(:empName,:salary)";
   	Employee employee = new Employee(null,"wangwu",999.9);
   	int update = namedParameterJdbcTemplate.update(sql,new BeanPropertySqlParameterSource(employee));
   	System.out.println(update);
   }
   

Cinq, utilisez JdbcTemplate pour réaliser Dao

• La classe JdbcTemplate est thread-safe, vous pouvez donc en déclarer une seule instance dans le conteneur IOC et injecter cette instance dans toutes les instances Dao.

Exemple de code:

EmployéDao

@Repository
public class EmployeeDao {
    
    
	
	@Autowired
	JdbcTemplate jdbcTemplate;
	public void saveEmployee(Employee employee){
    
    
		String sql = "INSERT INTO employee(emp_name,salary) VALUES(?,?)";
		jdbcTemplate.update(sql, employee.getEmpName(),employee.getSalary());
	}
}

test:

public class SpringTest {
    
    
	
	ApplicationContext ioc = new ClassPathXmlApplicationContext("ApplicationContext.xml");
	
	/**
	 * 创建BookDao，自动装配JdbcTemplate对象
	 */	
	@Test
	public void test09(){
    
    
		EmployeeDao employeeDao = ioc.getBean(EmployeeDao.class);
		employeeDao.saveEmployee(new Employee(null,"xiao",2343.0));
	}
}