iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #117 from mgooty/master 

Sample code for Spring JDBC examples.
This commit is contained in:
Eugen 2015-01-20 10:37:31 +02:00
parent 9e1ae6de70 17d3934094
commit 5bfbea1fff
10 changed files with 438 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
spring-all/pom.xml
View File

@ -50,7 +50,11 @@
<version>${mysql-connector-java.version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<version>2.3.2</version>
</dependency>
<!-- validation -->
<dependency>

23
spring-all/src/main/java/org/baeldung/jdbc/CustomSQLErrorCodeTranslator.java Normal file
View File

@ -0,0 +1,23 @@
package org.baeldung.jdbc;
import java.sql.SQLException;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator;
public class CustomSQLErrorCodeTranslator extends
SQLErrorCodeSQLExceptionTranslator {
@Override
protected DataAccessException customTranslate(final String task,
final String sql, final SQLException sqlException) {
if (sqlException.getErrorCode() == -104) {
return new DuplicateKeyException(
"Custome Exception translator - Integrity contraint voilation.",
sqlException);
}
return null;
}
}

44
spring-all/src/main/java/org/baeldung/jdbc/Employee.java Normal file
View File

@ -0,0 +1,44 @@
package org.baeldung.jdbc;
public class Employee {
private int id;
private String firstName;
private String lastName;
private String address;
public int getId() {
return id;
}
public void setId(final int id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(final String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(final String lastName) {
this.lastName = lastName;
}
public String getAddress() {
return address;
}
public void setAddress(final String address) {
this.address = address;
}
}

132
spring-all/src/main/java/org/baeldung/jdbc/EmployeeDAO.java Normal file
View File

@ -0,0 +1,132 @@
package org.baeldung.jdbc;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.stereotype.Repository;
@Repository
public class EmployeeDAO {
private JdbcTemplate jdbcTemplate;
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
private SimpleJdbcInsert simpleJdbcInsert;
@Autowired
public void setDataSource(final DataSource dataSource) {
jdbcTemplate = new JdbcTemplate(dataSource);
final CustomSQLErrorCodeTranslator customSQLErrorCodeTranslator = new CustomSQLErrorCodeTranslator();
jdbcTemplate.setExceptionTranslator(customSQLErrorCodeTranslator);
namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
simpleJdbcInsert = new SimpleJdbcInsert(dataSource)
.withTableName("EMPLOYEE");
}
public int getCountOfEmployees() {
return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM EMPLOYEE",
Integer.class);
}
public List<Employee> getAllEmployees() {
return jdbcTemplate.query("SELECT * FROM EMPLOYEE",
new EmployeeRowMapper());
}
public int addEmplyee(final int id) {
return jdbcTemplate.update("INSERT INTO EMPLOYEE VALUES (?, ?, ?, ?)",
id, "Bill", "Gates", "USA");
}
public int addEmplyeeUsingSimpelJdbcInsert(final Employee emp) {
final Map<String, Object> parameters = new HashMap<String, Object>();
parameters.put("ID", emp.getId());
parameters.put("FIRST_NAME", emp.getFirstName());
parameters.put("LAST_NAME", emp.getLastName());
parameters.put("ADDRESS", emp.getAddress());
return simpleJdbcInsert.execute(parameters);
}
public Employee getEmployee(final int id) {
final String query = "SELECT * FROM EMPLOYEE WHERE ID = ?";
return jdbcTemplate.queryForObject(query, new Object[] { id },
new EmployeeRowMapper());
}
public void addEmplyeeUsingExecuteMethod() {
jdbcTemplate
.execute("INSERT INTO EMPLOYEE VALUES (6, 'Bill', 'Gates', 'USA')");
}
public String getEmployeeUsingMapSqlParameterSource() {
final SqlParameterSource namedParameters = new MapSqlParameterSource()
.addValue("id", 1);
return namedParameterJdbcTemplate.queryForObject(
"SELECT FIRST_NAME FROM EMPLOYEE WHERE ID = :id",
namedParameters, String.class);
}
public int getEmployeeUsingBeanPropertySqlParameterSource() {
final Employee employee = new Employee();
employee.setFirstName("James");
final String SELECT_BY_ID = "SELECT COUNT(*) FROM EMPLOYEE WHERE FIRST_NAME = :firstName";
final SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(
employee);
return namedParameterJdbcTemplate.queryForObject(SELECT_BY_ID,
namedParameters, Integer.class);
}
public int[] batchUpdateUsingJDBCTemplate(final List<Employee> employees) {
return jdbcTemplate.batchUpdate(
"INSERT INTO EMPLOYEE VALUES (?, ?, ?, ?)",
new BatchPreparedStatementSetter() {
@Override
public void setValues(final PreparedStatement ps,
final int i) throws SQLException {
ps.setInt(1, employees.get(i).getId());
ps.setString(2, employees.get(i).getFirstName());
ps.setString(3, employees.get(i).getLastName());
ps.setString(4, employees.get(i).getAddress());
}
@Override
public int getBatchSize() {
return 3;
}
});
}
public int[] batchUpdateUsingNamedParameterJDBCTemplate(
final List<Employee> employees) {
final SqlParameterSource[] batch = SqlParameterSourceUtils
.createBatch(employees.toArray());
final int[] updateCounts = namedParameterJdbcTemplate
.batchUpdate(
"INSERT INTO EMPLOYEE VALUES (:id, :firstName, :lastName, :address)",
batch);
return updateCounts;
}
}

22
spring-all/src/main/java/org/baeldung/jdbc/EmployeeRowMapper.java Normal file
View File

@ -0,0 +1,22 @@
package org.baeldung.jdbc;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class EmployeeRowMapper implements RowMapper<Employee> {
@Override
public Employee mapRow(final ResultSet rs, final int rowNum)
throws SQLException {
final Employee employee = new Employee();
employee.setId(rs.getInt("ID"));
employee.setFirstName(rs.getString("FIRST_NAME"));
employee.setLastName(rs.getString("LAST_NAME"));
employee.setAddress(rs.getString("ADDRESS"));
return employee;
}
}

34
spring-all/src/main/java/org/baeldung/jdbc/config/SpringJdbcConfig.java Normal file
View File

@ -0,0 +1,34 @@
package org.baeldung.jdbc.config;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
@Configuration
@ComponentScan("org.baeldung.jdbc")
public class SpringJdbcConfig {
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.HSQL)
.addScript("classpath:jdbc/schema.sql")
.addScript("classpath:jdbc/test-data.sql").build();
}
// @Bean
public DataSource mysqlDataSource() {
final DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/springjdbc");
dataSource.setUsername("guest_user");
dataSource.setPassword("guest_password");
return dataSource;
}
}

7
spring-all/src/main/resources/jdbc/schema.sql Normal file
View File

@ -0,0 +1,7 @@
CREATE TABLE EMPLOYEE
(
ID int NOT NULL PRIMARY KEY,
FIRST_NAME varchar(255),
LAST_NAME varchar(255),
ADDRESS varchar(255),
);

20
spring-all/src/main/resources/jdbc/springJdbc-config.xml Normal file
View File

@ -0,0 +1,20 @@
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
<bean id="employeeDao" class="org.baeldung.jdbc.EmployeeDAO">
<property name="dataSource" ref="dataSource" />
</bean>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<context:property-placeholder location="jdbc.properties" />
</beans>

7
spring-all/src/main/resources/jdbc/test-data.sql Normal file
View File

@ -0,0 +1,7 @@
INSERT INTO EMPLOYEE VALUES (1, 'James', 'Gosling', 'Canada');
INSERT INTO EMPLOYEE VALUES (2, 'Donald', 'Knuth', 'USA');
INSERT INTO EMPLOYEE VALUES (3, 'Linus', 'Torvalds', 'Finland');
INSERT INTO EMPLOYEE VALUES (4, 'Dennis', 'Ritchie', 'USA');

144
spring-all/src/test/java/org/baeldung/jdbc/EmployeeDAOTest.java Normal file
View File

@ -0,0 +1,144 @@
package org.baeldung.jdbc;
import java.util.ArrayList;
import java.util.List;
import org.baeldung.jdbc.config.SpringJdbcConfig;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { SpringJdbcConfig.class }, loader = AnnotationConfigContextLoader.class)
public class EmployeeDAOTest {
@Autowired
private EmployeeDAO employeeDao;
@Test
public void testGetCountOfEmployees() {
Assert.assertEquals(employeeDao.getCountOfEmployees(), 9);
}
@Test
public void testQueryMethod() {
Assert.assertEquals(employeeDao.getAllEmployees().size(), 4);
}
@Test
public void testUpdateMethod() {
Assert.assertEquals(employeeDao.addEmplyee(5), 1);
}
@Test
public void testAddEmployeeUsingSimpelJdbcInsert() {
final Employee emp = new Employee();
emp.setId(11);
emp.setFirstName("testFirstName");
emp.setLastName("testLastName");
emp.setAddress("testAddress");
Assert.assertEquals(employeeDao.addEmplyeeUsingSimpelJdbcInsert(emp), 1);
}
@Test
public void testExecuteMethod() {
employeeDao.addEmplyeeUsingExecuteMethod();
}
@Test
public void testMapSqlParameterSource() {
Assert.assertEquals("James",
employeeDao.getEmployeeUsingMapSqlParameterSource());
}
@Test
public void testBeanPropertySqlParameterSource() {
Assert.assertEquals(1,
employeeDao.getEmployeeUsingBeanPropertySqlParameterSource());
}
@Test
public void testCustomExceptionTranslator() {
employeeDao.addEmplyee(7);
try {
employeeDao.addEmplyee(7);
} catch (final DuplicateKeyException e) {
System.out.println(e.getMessage());
Assert.assertTrue(e
.getMessage()
.contains(
"Custome Exception translator - Integrity contraint voilation."));
}
}
@Test
public void testBatchUpdateUsingJDBCTemplate() {
final List<Employee> employees = new ArrayList<Employee>();
final Employee emp1 = new Employee();
emp1.setId(10);
emp1.setFirstName("firstName1");
emp1.setLastName("lastName1");
emp1.setAddress("address1");
final Employee emp2 = new Employee();
emp2.setId(20);
emp2.setFirstName("firstName2");
emp2.setLastName("lastName2");
emp2.setAddress("address2");
final Employee emp3 = new Employee();
emp3.setId(30);
emp3.setFirstName("firstName3");
emp3.setLastName("lastName3");
emp3.setAddress("address3");
employees.add(emp1);
employees.add(emp2);
employees.add(emp3);
employeeDao.batchUpdateUsingJDBCTemplate(employees);
Assert.assertTrue(employeeDao.getEmployee(10) != null);
Assert.assertTrue(employeeDao.getEmployee(20) != null);
Assert.assertTrue(employeeDao.getEmployee(30) != null);
}
@Test
public void testBatchUpdateUsingNamedParameterJDBCTemplate() {
final List<Employee> employees = new ArrayList<Employee>();
final Employee emp1 = new Employee();
emp1.setId(40);
emp1.setFirstName("firstName4");
emp1.setLastName("lastName4");
emp1.setAddress("address4");
final Employee emp2 = new Employee();
emp2.setId(50);
emp2.setFirstName("firstName5");
emp2.setLastName("lastName5");
emp2.setAddress("address5");
final Employee emp3 = new Employee();
emp3.setId(60);
emp3.setFirstName("firstName6");
emp3.setLastName("lastName6");
emp3.setAddress("address6");
employees.add(emp1);
employees.add(emp2);
employees.add(emp3);
employeeDao.batchUpdateUsingNamedParameterJDBCTemplate(employees);
Assert.assertTrue(employeeDao.getEmployee(40) != null);
Assert.assertTrue(employeeDao.getEmployee(50) != null);
Assert.assertTrue(employeeDao.getEmployee(60) != null);
}
}