最近使用maven项目，由于前后端完全分离，不好测试，则先测试dao层的sql和方法是不是正确的
首先使用eclipse创建maven项目
pom.xml
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aop</artifactId> <version>4.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version>4.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>4.2.0.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>4.2.0.RELEASE</version> </dependency> <!-- junit集成测试 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>4.2.0.RELEASE</version> </dependency> <dependency> <groupId>com.mchange</groupId> <artifactId>c3p0</artifactId> <version>0.9.5</version> </dependency> <dependency> <groupId>com.oracle</groupId> <artifactId>ojdbc</artifactId> <version>6.0</version> </dependency> </dependencies>
接着就是spring的配置文件 了
既然做测试，配置文件从开发包复制一份到测试包（src/test/resources）下
jdbc.properties
jdbc.driverClassName=oracle.jdbc.driver.OracleDriver #jdbc.url=jdbc:mysql://localhost:3306/learn?#autoReconnect=true&useUnicode=true&characterEncoding=UTF-8 jdbc.url=jdbc:oracle:thin:@192.168.1.7:1521:jdbc jdbc.username=root jdbc.password=123456
beans.xml
<?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:mvc="http://www.springframework.org/schema/mvc"
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/mvc
http://www.springframework.org/schema/mvc/spring-mvc.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:annotation-config/>
<!-- 组件扫描 -->
<context:component-scan base-package="com.share.*"/>
<!--数据库配置:配置jdbc.properties -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 3、配置dataSource数据源c3p0 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClassName}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<!-- <property name="maxPoolSize" value="${c3p0.pool.maxPoolSize}"/>
<property name="minPoolSize" value="${c3p0.pool.minPoolSize}"/>
<property name="initialPoolSize" value="${c3p0.pool.initialPoolSize}"/>
<property name="acquireIncrement" value="${c3p0.pool.acquireIncrement}"/> -->
</bean>
<!-- JDBCTemplate注入 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name = "dataSource" ref="dataSource"/>
</bean>
<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<constructor-arg ref="dataSource"/>
</bean>
<!-- mybatis配置文件
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
自动扫描mapping.xml文件
<property name="mapperLocations" value="classpath:com/share/mapping/*.xml"></property>
<property name="configLocations" value="classpath:mybatis.xml"/> >
定义包的别名
<property name="typeAliasesPackage" value="com.share.domain"></property>
</bean>-->
<!-- DAO接口所在包名，Spring会自动查找其下的类
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.share.dao" />
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
</bean> -->
<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean> -->
</beans>
实体User
public class User implements Serializable {
private static final long serialVersionUID = -1235134923224170420L;
private Integer id;
private String username;
private String password;
private String email;
private String phone;
private Integer age;
private Integer sex;
private String address;
private Date birth;
........get set方法 省略
}
数据库根据实体建就行了
dao层代码
package com.share.dao;
import java.sql.Types;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.support.DataAccessUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.ColumnMapRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapperResultSetExtractor;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
import org.springframework.stereotype.Repository;
import com.share.domain.User;
@Repository
public class BaseDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Autowired
private NamedParameterJdbcTemplate nameParameterJdbcTemplate;
/**
* 添加用户
* @param user
* @return
*/
public int insert(User user) {
String sql = "insert into tuser (id, username, password, email, phone, age, sex, address, birth) values (?, ?, ?, ?, ?, ?, ?, ?, ?)";
Object[] obj = new Object[]{getSeq("seq_user"), user.getUsername(), user.getPassword(), user.getEmail(), user.getPhone(), user.getAge(), user.getSex(), user.getAddress(), user.getBirth()};
int[] types = new int[]{Types.INTEGER, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.DATE};
return jdbcTemplate.update(sql, obj, types);
}
private Integer getSeq(String seqName) {
String sql = "select " + seqName + ".nextval from dual";
return jdbcTemplate.queryForObject(sql, Integer.class);
}
/**
* nameParameterJdbcTemplate添加用户
* @param user
* @return
*/
public int insertUser(User user) {
user.setId(getSeq("seq_user"));
String sql = "insert into tuser (id, username, password, email, phone, age, sex, address, birth) values (:id, :username, :password, :email, :phone, :age, :sex, :address, :birth)";
SqlParameterSource source = new BeanPropertySqlParameterSource(user);
return nameParameterJdbcTemplate.update(sql, source);
}
/**
* nameParameterJdbcTemplate添加用户
* @param user
* @return
*/
public int batchInsertUser(User user) {
user.setId(getSeq("seq_user"));
String sql = "insert into tuser (id, username, password, email, phone, age, sex, address, birth) values (:id, :username, :password, :email, :phone, :age, :sex, :address, :birth)";
SqlParameterSource source = new BeanPropertySqlParameterSource(user);
return nameParameterJdbcTemplate.update(sql, source);
}
/**
* 批量添加
* @param users
* @return
*/
public int batchInsert(User[] users) {
String sql = "insert into tuser (id, username, password, email, phone, age, sex, address, birth) values (?, ?, ?, ?, ?, ?, ?, ?, ?)";
int[] types = new int[]{Types.INTEGER, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.DATE};
List<Object[]> list = new ArrayList<Object[]>();
for(User user : users) {
list.add(new Object[]{getSeq("seq_user"),user.getUsername(), user.getPassword(), user.getEmail(), user.getPhone(), user.getAge(), user.getSex(), user.getAddress(), user.getBirth()});
}
//list.add(users);
return jdbcTemplate.batchUpdate(sql, list, types).length;
}
/**
* 批量更新
*/
//public int batchUpdateBeans(String insertSql, List<? extends Object> beans) {
public int batchUpdateBeans(List<? extends Object> beans) {
String sql = "insert into tuser (id, username, password, email, phone, age, sex, address, birth) values (seq_user.nextval, :username, :password, :email, :phone, :age, :sex, :address, :birth)";
int[] results = null;
try {
SqlParameterSource[] params = SqlParameterSourceUtils.createBatch(beans.toArray());
results = nameParameterJdbcTemplate.batchUpdate(sql, params);
} catch (Exception e) {
e.printStackTrace();
}
return results.length;
}
/**
* 查询单个对象
* @param id
* @return
*/
public User findUserById(Integer id) {
String sql = "select * from tuser where id = ?";
//return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class),id);
List<User> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class), id);
return DataAccessUtils.uniqueResult(query);
}
/**
* 查询单个对象
* @param id
* @return
*/
public Map<String, Object> findUserMap(Integer id) {
String sql = "select * from tuser where id = ?";
Object[] args = new Object[]{id};
List<Map<String, Object>> results =
jdbcTemplate.query(sql, args, new RowMapperResultSetExtractor<Map<String, Object>>(new ColumnMapRowMapper(), 1));
return DataAccessUtils.uniqueResult(results);
}
}
src/test/java中的测试代码
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:beans.xml"})
public class JdbcTest {
@Autowired
private BaseDao baseDao;
@Test
public void insertTest() {
User user = new User();
user.setUsername("admin");
user.setPassword("123456");
user.setEmail("admin@163.com");
user.setPhone("110");
user.setSex(1);
user.setAge(25);
user.setBirth(DateUtils.str2Date("1990-01-31 13:14:15"));
user.setAddress("上海");
baseDao.insert(user);
}
@Test
public void batchInsert() {
User user = new User();
user.setUsername("share");
user.setPassword("123456");
user.setEmail("admin@163.com");
user.setPhone("120");
user.setSex(1);
user.setAge(25);
user.setBirth(DateUtils.str2Date("1990-01-31 13:14:15"));
user.setAddress("天津");
User user1 = new User();
user1.setUsername("share");
user1.setPassword("123456");
user1.setEmail("admin@163.com");
user1.setPhone("120");
user1.setSex(1);
user1.setAge(25);
user1.setBirth(DateUtils.str2Date("1990-01-31 13:14:15"));
user1.setAddress("北京");
User[] users = new User[]{user, user1};
baseDao.batchInsert(users);
}
@Test
public void findUser() {
User user = baseDao.findUserById(1001);
System.out.println(user);
}
@Test
public void findUserMap() {
Map<String, Object> user = baseDao.findUserMap(1001);
System.out.println(user.get("ID") + "::" + user.get("USERNAME"));
}
@Test
public void addUser() {
User user = new User();
user.setUsername("风平浪静");
user.setPassword("123456");
user.setEmail("fengpinglangjing@163.com");
user.setPhone("110");
user.setSex(1);
user.setAge(25);
user.setBirth(DateUtils.str2Date("1990-01-31 13:14:15"));
user.setAddress("上海");
baseDao.insertUser(user);
}
@Test
public void batchAddUser() {
User user = new User();
user.setUsername("share1");
user.setPassword("123456");
user.setEmail("admin@163.com");
user.setPhone("120");
user.setSex(1);
user.setAge(25);
user.setBirth(DateUtils.str2Date("1990-01-31 13:14:15"));
user.setAddress("天津");
User user1 = new User();
user1.setUsername("share2");
user1.setPassword("123456");
user1.setEmail("admin@163.com");
user1.setPhone("120");
user1.setSex(1);
user1.setAge(25);
user1.setBirth(DateUtils.str2Date("1990-01-31 13:14:15"));
user1.setAddress("北京");
List<User> users = new ArrayList<User>();
users.add(user1);
users.add(user);
//User[] users = new User[]{user, user1};
baseDao.batchUpdateBeans(users);
}
}
接着就是数据库查看记录是否跟自己写的sql匹配判断结果是否正确了……
相关推荐
这个测试类使用了Spring的测试支持，通过`@RunWith(SpringJUnit4ClassRunner.class)`和`@ContextConfiguration`注解来加载Spring上下文，然后通过@Autowired自动注入UserDAO。测试方法`testAddAndGetUsers`模拟了...
这是一个基于Spring MVC、Hibernate、Spring和Maven技术栈构建的学生管理系统源码项目。这个系统旨在实现对学生信息的高效管理和操作，提供了一整套完整的后端服务。以下将详细阐述这些技术及其在项目中的应用。 **...
项目可能包含了JUnit测试类，用于验证数据库操作的正确性。通过单元测试，可以确保每个功能模块的独立性和稳定性。 10. **最佳实践**： 为了遵循最佳实践，项目可能使用了DAO（Data Access Object）设计模式，将...
5. 测试：利用Spring的测试支持，编写JUnit测试以验证Bean的配置和功能。 四、SpringDemo和SpringDemo2 从提供的压缩文件名来看，SpringDemo和SpringDemo2很可能是两个示例项目。它们可能包含了Spring应用的基础...
4. **DAO层设计**：定义数据访问对象（DAO），这些对象将使用Spring提供的模板类来执行数据库操作。例如，你可以创建一个`UserDao`接口，然后使用`@Repository`注解标记实现类。 5. **Service层设计**：业务逻辑...
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = {"classpath:applicationContext.xml"}) public class DataSourceTest { @Autowired private DataSource dataSource; @Test ...
4. 依赖库：如pom.xml（如果是Maven项目）或build.gradle（如果是Gradle项目），列出了项目所需的依赖项。 5. 运行和部署文档：指导如何启动和运行项目，以及如何配置和连接到Redis服务器。 学习并掌握这个技术组合...
1. **项目结构**：源码中的目录结构通常反映了典型的Maven或Gradle项目结构，包括`src/main/java`（业务逻辑代码）、`src/main/resources`（配置文件）和`src/test/java`（测试代码）等。 2. **配置文件**：如`...
- 可以使用JUnit和Mockito进行单元测试，Spring Test支持集成测试。 在搭建过程中，需要注意的是，纯Spring环境可能会比Spring Boot等现代化框架更繁琐，因为许多配置需要手动完成。但是，它有助于深入理解Spring...
8. **单元测试**：整合后的项目通常会包含针对Service层和DAO层的单元测试，使用JUnit和Mockito等工具，确保代码的正确性和健壮性。 9. **Maven或Gradle构建工具**：为了项目的管理和构建，可以使用Maven或Gradle，...
接着，通过Spring的DAO模板（如JdbcTemplate或HibernateTemplate）将ORM操作委托给Hibernate，这样可以避免直接在业务逻辑代码中处理数据库细节。 5. **Web服务配置**： 要实现Web服务，Spring需要配置一个Servlet...
但通常，一个名为“maventest11”的文件可能是一个Maven项目的测试部分，可能包含了Spring数据访问相关的测试代码，例如使用JUnit或者TestNG进行的数据库操作测试。 总的来说，Spring数据访问涵盖了广泛的领域，从...
创建JUnit测试用例，验证Spring和Hibernate整合后的数据访问功能是否正常工作，例如，通过调用DAO方法，检查数据的保存、查询、更新和删除是否符合预期。 6. **Spring MVC与Hibernate**： 如果是Web应用，还需要...
关于Spring中的单元测试，教程中提到了使用JUnit进行测试的方法，包括导入必要的maven依赖、创建测试类、使用@RunWith注解和@ContextConfiguration注解指定Spring配置文件，以及编写测试方法。单元测试是保证代码...
1. **项目结构**：通常，Spring Boot项目遵循标准的Maven或Gradle目录结构，包括`src/main/java`（源代码）、`src/main/resources`（资源文件）、`src/test/java`（测试代码）等。此外，可能会有特定的目录用于存放...
此外，项目中可能还涉及到了其他技术，例如：使用Maven或Gradle进行项目构建，使用JUnit和Mockito进行单元测试，使用Eclipse或IntelliJ IDEA作为开发环境，使用Git进行版本控制，以及使用Tomcat或Jetty作为应用...
6. **创建DAO层**：定义数据访问对象（DAO），使用Spring的`HibernateTemplate`或`JdbcTemplate`进行数据操作。 7. **实现业务逻辑**：在Service层，利用DAO实现业务逻辑，同时可以通过Spring的`@Transactional`注解...
6. 测试：编写JUnit测试用例，验证SSH集成是否正确，数据库操作是否有效。 这个实例可能还涉及到一些其他工具，如Maven或Gradle来管理依赖，Eclipse或IntelliJ IDEA等IDE进行开发，以及Git进行版本控制。通过阅读...
此外，你还会接触到日志记录（如Log4j或Logback）、单元测试（JUnit和Mockito）等方面的知识，这些都是软件开发中的重要实践。 总的来说，通过【HelloWorld.zip】，你可以系统地学习Spring框架的基本概念，以及如何...
此外，开发过程中通常会结合使用其他技术，如Maven或Gradle进行项目构建，使用JUnit和Mockito进行单元测试，使用Eclipse或IntelliJ IDEA等IDE提高开发效率，使用Git进行版本控制。系统的部署可能涉及到Tomcat、Jetty...