SPRING IN ACTION 第4版笔记-第十章Hitting the database with spring and jdbc-002-本章的源代码

0.结构

一、JDBC层

1.

package spittr.db;

import java.util.List;

import spittr.domain.Spitter;

/**
 * Repository interface with operations for {@link Spitter} persistence.
 * @author habuma
 */
public interface SpitterRepository {

  long count();
  
  Spitter save(Spitter spitter);
  
  Spitter findOne(long id);

  Spitter findByUsername(String username);

  List<Spitter> findAll();

}

2.

package spittr.db;

import java.util.List;

import spittr.domain.Spittle;

/**
 * Repository interface with operations for {@link Spittle} persistence.
 * @author habuma
 */
public interface SpittleRepository {

  long count();
  
  List<Spittle> findRecent();

  List<Spittle> findRecent(int count);

  Spittle findOne(long id);

  Spittle save(Spittle spittle);
    
  List<Spittle> findBySpitterId(long spitterId);
  
  void delete(long id);
    
}

3.

package spittr.db.jdbc;

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

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;

import spittr.db.SpitterRepository;
import spittr.domain.Spitter;

public class JdbcSpitterRepository implements SpitterRepository {
    
    private JdbcTemplate jdbcTemplate;

    public JdbcSpitterRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;        
    }

    public long count() {
        //return jdbcTemplate.queryForLong("select count(id) from Spitter");
        return jdbcTemplate.queryForObject("select count(id) from Spitter", Long.class);
    }

    public Spitter save(Spitter spitter) {
        Long id = spitter.getId();
        if (id == null) {
            long spitterId = insertSpitterAndReturnId(spitter);
            return new Spitter(spitterId, spitter.getUsername(), spitter.getPassword(), spitter.getFullName(), spitter.getEmail(), spitter.isUpdateByEmail());
        } else {
            jdbcTemplate.update("update Spitter set username=?, password=?, fullname=?, email=?, updateByEmail=? where id=?",                    
                    spitter.getUsername(),
                    spitter.getPassword(),
                    spitter.getFullName(),
                    spitter.getEmail(),
                    spitter.isUpdateByEmail(),
                    id);
        }
        return spitter;
    }

    /**
     * Inserts a spitter using SimpleJdbcInsert. 
     * Involves no direct SQL and is able to return the ID of the newly created Spitter.
     * @param spitter a Spitter to insert into the databse
     * @return the ID of the newly inserted Spitter
     */
    private long insertSpitterAndReturnId(Spitter spitter) {
        SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate).withTableName("Spitter");
        jdbcInsert.setGeneratedKeyName("id");
        Map<String, Object> args = new HashMap<String, Object>();
        args.put("username", spitter.getUsername());
        args.put("password", spitter.getPassword());
        args.put("fullname", spitter.getFullName());
        args.put("email", spitter.getEmail());
        args.put("updateByEmail", spitter.isUpdateByEmail());
        long spitterId = jdbcInsert.executeAndReturnKey(args).longValue();
        return spitterId;
    }

    /**
     * Inserts a spitter using a simple JdbcTemplate update() call.
     * Does not return the ID of the newly created Spitter.
     * @param spitter a Spitter to insert into the database
     */
    @SuppressWarnings("unused")
    private void insertSpitter(Spitter spitter) {
        jdbcTemplate.update(INSERT_SPITTER, 
            spitter.getUsername(),
            spitter.getPassword(),
            spitter.getFullName(),
            spitter.getEmail(),
            spitter.isUpdateByEmail());
    }

  public Spitter findOne(long id) {
    return jdbcTemplate.queryForObject(
            SELECT_SPITTER + " where id=?", new SpitterRowMapper(), id);
  }

    public Spitter findByUsername(String username) {
        return jdbcTemplate.queryForObject("select id, username, password, fullname, email, updateByEmail from Spitter where username=?", new SpitterRowMapper(), username);
  }

    public List<Spitter> findAll() {
        return jdbcTemplate.query("select id, username, password, fullname, email, updateByEmail from Spitter order by id", new SpitterRowMapper());
    }

    private static final class SpitterRowMapper implements RowMapper<Spitter> {
        public Spitter mapRow(ResultSet rs, int rowNum) throws SQLException {
            long id = rs.getLong("id");
            String username = rs.getString("username");
            String password = rs.getString("password");
            String fullName = rs.getString("fullname");
            String email = rs.getString("email");
            boolean updateByEmail = rs.getBoolean("updateByEmail");
            return new Spitter(id, username, password, fullName, email, updateByEmail);
        }        
    }

    private static final String INSERT_SPITTER = "insert into Spitter (username, password, fullname, email, updateByEmail) values (?, ?, ?, ?, ?)";

    private static final String SELECT_SPITTER = "select id, username, password, fullname, email, updateByEmail from Spitter";

}

4.

package spittr.db.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;

import spittr.db.SpittleRepository;
import spittr.domain.Spitter;
import spittr.domain.Spittle;

public class JdbcSpittleRepository implements SpittleRepository {

    private static final String SELECT_SPITTLE = "select sp.id, s.id as spitterId, s.username, s.password, s.fullname, s.email, s.updateByEmail, sp.message, sp.postedTime from Spittle sp, Spitter s where sp.spitter = s.id";
    private static final String SELECT_SPITTLE_BY_ID = SELECT_SPITTLE + " and sp.id=?";
    private static final String SELECT_SPITTLES_BY_SPITTER_ID = SELECT_SPITTLE + " and s.id=? order by sp.postedTime desc";
    private static final String SELECT_RECENT_SPITTLES = SELECT_SPITTLE + " order by sp.postedTime desc limit ?";
    
    private JdbcTemplate jdbcTemplate;

    public JdbcSpittleRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public long count() {
        //return jdbcTemplate.queryForLong("select count(id) from Spittle");
        return jdbcTemplate.queryForObject("select count(id) from Spittle", Long.class);
    }

    public List<Spittle> findRecent() {
        return findRecent(10);
    }

    public List<Spittle> findRecent(int count) {
        return jdbcTemplate.query(SELECT_RECENT_SPITTLES, new SpittleRowMapper(), count);
    }

    public Spittle findOne(long id) {
        try {
            return jdbcTemplate.queryForObject(SELECT_SPITTLE_BY_ID, new SpittleRowMapper(), id);
        } catch (EmptyResultDataAccessException e) {
            return null;
        }
    }

    public List<Spittle> findBySpitterId(long spitterId) {
        return jdbcTemplate.query(SELECT_SPITTLES_BY_SPITTER_ID, new SpittleRowMapper(), spitterId);
    }

    public Spittle save(Spittle spittle) {
        long spittleId = insertSpittleAndReturnId(spittle);
        return new Spittle(spittleId, spittle.getSpitter(), spittle.getMessage(), spittle.getPostedTime());
    }

    private long insertSpittleAndReturnId(Spittle spittle) {
            SimpleJdbcInsert jdbcInsert = new SimpleJdbcInsert(jdbcTemplate).withTableName("Spittle");
            jdbcInsert.setGeneratedKeyName("id");
            Map<String, Object> args = new HashMap<String, Object>();
            args.put("spitter", spittle.getSpitter().getId());
            args.put("message", spittle.getMessage());
            args.put("postedTime", spittle.getPostedTime());
            long spittleId = jdbcInsert.executeAndReturnKey(args).longValue();
            return spittleId;
    }

    public void delete(long id) {
        jdbcTemplate.update("delete from Spittle where id=?", id);
    }
    
    private static final class SpittleRowMapper implements RowMapper<Spittle> {
        public Spittle mapRow(ResultSet rs, int rowNum) throws SQLException {
            long id = rs.getLong("id");
            String message = rs.getString("message");
            Date postedTime = rs.getTimestamp("postedTime");
            long spitterId = rs.getLong("spitterId");
            String username = rs.getString("username");
            String password = rs.getString("password");
            String fullName = rs.getString("fullname");
            String email = rs.getString("email");
            boolean updateByEmail = rs.getBoolean("updateByEmail");
            Spitter spitter = new Spitter(spitterId, username, password, fullName, email, updateByEmail);
            return new Spittle(id, spitter, message, postedTime);
        }
    }

}

二、Domain层

1.

package spittr.domain;

public class Spitter {
  
  private Long id;
  private String username;
  private String password;
  private String fullName;
  private String email;
  private boolean updateByEmail;

  public Spitter(Long id, String username, String password, String fullName, String email, boolean updateByEmail) {
    this.id = id;
    this.username = username;
    this.password = password;
    this.fullName = fullName;
    this.email = email;
    this.updateByEmail = updateByEmail;
  }

  public Long getId() {
    return id;
  }

  public String getUsername() {
    return username;
  }

  public String getPassword() {
    return password;
  }

  public String getFullName() {
    return fullName;
  }

  public String getEmail() {
    return email;
  }

  public boolean isUpdateByEmail() {
    return updateByEmail;
  }

}

2.

package spittr.domain;

import java.util.Date;

public class Spittle {
  private final Long id;
  private final Spitter spitter;
  private final String message;
  private final Date postedTime;

  public Spittle(Long id, Spitter spitter, String message, Date postedTime) {
    this.id = id;
    this.spitter = spitter;
    this.message = message;
    this.postedTime = postedTime;
  }
  
  public Long getId() {
    return this.id;
  }
  
  public String getMessage() {
    return this.message;
  }
  
  public Date getPostedTime() {
    return this.postedTime;
  }

  public Spitter getSpitter() {
    return this.spitter;
  }

}

三、配置文件及数据库文件

1.JdbcConfig.java

package spittr.jdbc;

import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
import org.springframework.transaction.PlatformTransactionManager;

import spittr.db.SpitterRepository;
import spittr.db.SpittleRepository;
import spittr.db.jdbc.JdbcSpitterRepository;
import spittr.db.jdbc.JdbcSpittleRepository;

@Configuration
public class JdbcConfig {

  @Bean
  public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder()
      .setType(EmbeddedDatabaseType.H2)
      .addScripts("classpath:spittr/db/jdbc/schema.sql", "classpath:spittr/db/jdbc/test-data.sql")
      .build();
  }
  
  @Bean
  public JdbcTemplate jdbcTemplate(DataSource dataSource) {
    return new JdbcTemplate(dataSource);
  }
  
  @Bean
  public SpitterRepository spitterRepository(JdbcTemplate jdbcTemplate) {
    return new JdbcSpitterRepository(jdbcTemplate);
  }

  @Bean
  public SpittleRepository spittleRepository(JdbcTemplate jdbcTemplate) {
    return new JdbcSpittleRepository(jdbcTemplate);
  }
  
  @Bean
  public PlatformTransactionManager transactionManager(DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
  }

}

2.或用xml配置(JdbcRepositoryTests-context.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:c="http://www.springframework.org/schema/c"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xsi:schemaLocation="http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

  <jdbc:embedded-database id="dataSource" type="H2">
    <jdbc:script location="classpath:spittr/db/jdbc/schema.sql" />
    <jdbc:script location="classpath:spittr/db/jdbc/test-data.sql" />
  </jdbc:embedded-database>

  <bean id="jdbcTemplate"
        class="org.springframework.jdbc.core.JdbcTemplate" 
        c:_-ref="dataSource" />

  <bean class="spittr.db.jdbc.JdbcSpitterRepository"
        c:_-ref="jdbcTemplate" />

  <bean class="spittr.db.jdbc.JdbcSpittleRepository"
        c:_-ref="jdbcTemplate" />

  <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager" 
        c:_-ref="dataSource" />
 
</beans>

3.schema.sql

drop table if exists spittle;
drop table if exists spitter;

create table spitter (
  id identity,
  username varchar(25) not null,
  password varchar(25) not null,
  fullName varchar(100) not null,
  email varchar(50) not null,
  updateByEmail boolean not null
);

create table spittle (
  id integer identity primary key,
  spitter integer not null,
  message varchar(2000) not null,
  postedTime datetime not null,
  foreign key (spitter) references spitter(id)
);

4.test-data.sql

insert into Spitter (username, password, fullname, email, updateByEmail) values ('habuma', 'password', 'Craig Walls', 'craig@habuma.com', false);
insert into Spitter (username, password, fullname, email, updateByEmail) values ('mwalls', 'password', 'Michael Walls', 'mwalls@habuma.com', true);
insert into Spitter (username, password, fullname, email, updateByEmail) values ('chuck', 'password', 'Chuck Wagon', 'chuck@habuma.com', false);
insert into Spitter (username, password, fullname, email, updateByEmail) values ('artnames', 'password', 'Art Names', 'art@habuma.com', true);

insert into Spittle (spitter, message, postedTime) values (1, 'This is a test spittle message', '2012-06-09 22:00:00Z');
insert into Spittle (spitter, message, postedTime) values (1, 'This is another test spittle message', '2012-06-09 22:10:00Z');
insert into Spittle (spitter, message, postedTime) values (1, 'This is a third test spittle message', '2012-07-04 23:30:00Z');
insert into Spittle (spitter, message, postedTime) values (2, 'Hello from Chuck!', '2012-03-25 12:15:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Hello from Art!', '2012-03-25 12:15:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Hello again from Art!', '2012-03-25 12:25:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Hola from Arthur!', '2012-03-25 12:35:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Buenos Dias from Art!', '2012-03-25 12:45:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Ni Hao from Art!', '2012-03-25 12:55:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Guten Tag from Art!', '2012-03-25 13:05:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Konnichi wa from Art!', '2012-03-25 13:15:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Buon giorno from Art!', '2012-03-25 13:25:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Bonjour from Art!', '2012-03-25 13:35:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'Aloha from Art!', '2012-03-25 13:45:00Z');
insert into Spittle (spitter, message, postedTime) values (4, 'God dag from Art!', '2012-03-25 13:55:00Z');

四、测试文件

1.

package spittr.jdbc;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import spittr.db.jdbc.JdbcSpitterRepository;
import spittr.domain.Spitter;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=JdbcConfig.class)
public class JdbcSpitterRepositoryTest {

  @Autowired
  JdbcSpitterRepository spitterRepository;

  @Test
  public void count() {
    assertEquals(4, spitterRepository.count());
  }

  @Test
  @Transactional
  public void findAll() {
    List<Spitter> spitters = spitterRepository.findAll();
    assertEquals(4, spitters.size());
    assertSpitter(0, spitters.get(0));
    assertSpitter(1, spitters.get(1));
    assertSpitter(2, spitters.get(2));
    assertSpitter(3, spitters.get(3));
  }

  @Test
  @Transactional
  public void findByUsername() {
    assertSpitter(0, spitterRepository.findByUsername("habuma"));
    assertSpitter(1, spitterRepository.findByUsername("mwalls"));
    assertSpitter(2, spitterRepository.findByUsername("chuck"));
    assertSpitter(3, spitterRepository.findByUsername("artnames"));
  }

  @Test
  @Transactional
  public void findOne() {
    assertSpitter(0, spitterRepository.findOne(1L));
    assertSpitter(1, spitterRepository.findOne(2L));
    assertSpitter(2, spitterRepository.findOne(3L));
    assertSpitter(3, spitterRepository.findOne(4L));
  }

  @Test
  @Transactional
  public void save_newSpitter() {
    assertEquals(4, spitterRepository.count());
    Spitter spitter = new Spitter(null, "newbee", "letmein", "New Bee",
        "newbee@habuma.com", true);
    Spitter saved = spitterRepository.save(spitter);
    assertEquals(5, spitterRepository.count());
    assertSpitter(4, saved);
    assertSpitter(4, spitterRepository.findOne(5L));
  }

  @Test
  @Transactional
  public void save_existingSpitter() {
    assertEquals(4, spitterRepository.count());
    Spitter spitter = new Spitter(4L, "arthur", "letmein", "Arthur Names",
        "arthur@habuma.com", false);
    Spitter saved = spitterRepository.save(spitter);
    assertSpitter(5, saved);
    assertEquals(4, spitterRepository.count());
    Spitter updated = spitterRepository.findOne(4L);
    assertSpitter(5, updated);
  }

  private static void assertSpitter(int expectedSpitterIndex, Spitter actual) {
    assertSpitter(expectedSpitterIndex, actual, "Newbie");
  }

  private static void assertSpitter(int expectedSpitterIndex, Spitter actual,
      String expectedStatus) {
    Spitter expected = SPITTERS[expectedSpitterIndex];
    assertEquals(expected.getId(), actual.getId());
    assertEquals(expected.getUsername(), actual.getUsername());
    assertEquals(expected.getPassword(), actual.getPassword());
    assertEquals(expected.getFullName(), actual.getFullName());
    assertEquals(expected.getEmail(), actual.getEmail());
    assertEquals(expected.isUpdateByEmail(), actual.isUpdateByEmail());
  }

  private static Spitter[] SPITTERS = new Spitter[6];

  @BeforeClass
  public static void before() {
    SPITTERS[0] = new Spitter(1L, "habuma", "password", "Craig Walls",
        "craig@habuma.com", false);
    SPITTERS[1] = new Spitter(2L, "mwalls", "password", "Michael Walls",
        "mwalls@habuma.com", true);
    SPITTERS[2] = new Spitter(3L, "chuck", "password", "Chuck Wagon",
        "chuck@habuma.com", false);
    SPITTERS[3] = new Spitter(4L, "artnames", "password", "Art Names",
        "art@habuma.com", true);
    SPITTERS[4] = new Spitter(5L, "newbee", "letmein", "New Bee",
        "newbee@habuma.com", true);
    SPITTERS[5] = new Spitter(4L, "arthur", "letmein", "Arthur Names",
        "arthur@habuma.com", false);
  }

}

2.

package spittr.jdbc;

import static org.junit.Assert.*;

import java.util.Date;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import spittr.db.jdbc.JdbcSpittleRepository;
import spittr.domain.Spitter;
import spittr.domain.Spittle;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=JdbcConfig.class)
public class JdbcSpittleRepositoryTest {

  @Autowired
  JdbcSpittleRepository spittleRepository;

  @Test
  public void count() {
    assertEquals(15, spittleRepository.count());
  }

  @Test
  public void findRecent() {
    // default case
    {
      List<Spittle> recent = spittleRepository.findRecent();
      assertRecent(recent, 10);
    }

    // specific count case
    {
      List<Spittle> recent = spittleRepository.findRecent(5);
      assertRecent(recent, 5);
    }
  }

  @Test
  public void findOne() {
    Spittle thirteen = spittleRepository.findOne(13);
    assertEquals(13, thirteen.getId().longValue());
    assertEquals("Bonjour from Art!", thirteen.getMessage());
    assertEquals(1332682500000L, thirteen.getPostedTime().getTime());
    assertEquals(4, thirteen.getSpitter().getId().longValue());
    assertEquals("artnames", thirteen.getSpitter().getUsername());
    assertEquals("password", thirteen.getSpitter().getPassword());
    assertEquals("Art Names", thirteen.getSpitter().getFullName());
    assertEquals("art@habuma.com", thirteen.getSpitter().getEmail());
    assertTrue(thirteen.getSpitter().isUpdateByEmail());
  }

  @Test
  public void findBySpitter() {
    List<Spittle> spittles = spittleRepository.findBySpitterId(4L);
    assertEquals(11, spittles.size());
    for (int i = 0; i < 11; i++) {
      assertEquals(15 - i, spittles.get(i).getId().longValue());
    }
  }

  @Test
  @Transactional
  public void save() {
    assertEquals(15, spittleRepository.count());
    Spitter spitter = spittleRepository.findOne(13).getSpitter();
    Spittle spittle = new Spittle(null, spitter, "Un Nuevo Spittle from Art",
        new Date());
    Spittle saved = spittleRepository.save(spittle);
    assertEquals(16, spittleRepository.count());
    assertNewSpittle(saved);
    assertNewSpittle(spittleRepository.findOne(16L));
  }

  @Test
  @Transactional
  public void delete() {
    assertEquals(15, spittleRepository.count());
    assertNotNull(spittleRepository.findOne(13));
    spittleRepository.delete(13L);
    assertEquals(14, spittleRepository.count());
    assertNull(spittleRepository.findOne(13));
  }

  private void assertRecent(List<Spittle> recent, int count) {
    long[] recentIds = new long[] { 3, 2, 1, 15, 14, 13, 12, 11, 10, 9 };
    assertEquals(count, recent.size());
    for (int i = 0; i < count; i++) {
      assertEquals(recentIds[i], recent.get(i).getId().longValue());
    }
  }

  private void assertNewSpittle(Spittle spittle) {
    assertEquals(16, spittle.getId().longValue());
  }

}