1. 创建数据库和表

在小节UID替换器的实现中，我们设计了一个表。这部分就按照这个表实现CRUD，表情况如下：

--- table idmapper
id int 规则ID 自增
name varchar 规则名
source_id varchar 源ID
direct_id varchar 目的ID
enable int 是否启用 0:不启用，1:启用

这里面数据库采用通用的MySQL数据库，先在MySQL中创建一个名为springdemo的数据库：

CREATE DATABASE springdemo DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

Intellij提供了专门的数据库管理插件，这是界面：

数据库界面

接下来既可以用Intellij提供的数据库工具创建idmapper表，又可以用SQL创建语句来处理，这里直接使用创建语句创建。

create table id_mapper(
  id INT NOT NULL AUTO_INCREMENT,
  name VARBINARY(255) NOT NULL,
  source_id VARBINARY(255) NOT NULL,
  direct_id VARBINARY(255) NOT NULL,
  enable INT DEFAULT 1,
  PRIMARY KEY (id)
);

运行后的结果是：

运行结果界面

往数据库里面插入两条数据用于测试，看看结果：

数据库数据

目前数据没有啥问题了，我们开始按照常用的SpringMVC方法开发我们的应用。

2. Pojo 对象

由于不使用ORM框架(Mybatis或Hibernate)，我们自己使用简单的SQL来处理数据的CRUD，就需要定义一个Pojo类，同数据库中的表定义对应。这个类的对象与表中每一行数据对应。定义这个Pojo类如下：

public class IdMapper {

    private int id;
    private String name;
    private String sourceId;
    private String directId;
    /**
     * enable 状态
     * 0 表示停用
     * 1 表示开启
     */
    private int enable;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSourceId() {
        return sourceId;
    }

    public void setSourceId(String sourceId) {
        this.sourceId = sourceId;
    }

    public String getDirectId() {
        return directId;
    }

    public void setDirectId(String directId) {
        this.directId = directId;
    }

    public boolean getEnable() {
        return enable==1;
    }

    public void setEnable(boolean enable) {
        this.enable = enable?1:0;
    }

}

3. Pojo对象操作类

有了Pojo对象之后，我们需要实现这个Pojo对象的操作类。如果用的是Python，使用Sqlalchemy或Django自己的ORM，然后定义类似的Pojo类就能够自动实现对Pojo对象的查询。但是Java这方面的功能我还不清楚，应该是没有这么好用的功能，主要原因是Java是静态语言，而这些功能是动态运行时生成的，例如查询方法，像Python和Ruby这样的脚本语言能够做到，而静态语言就不容易做到了。

Java的话，此处就直接实现Pojo对象的操作类。按照面向接口编程的原则，我们先设计一个IdMapperDao的接口，如下：

public interface IdMapperDao {

    int insert(final IdMapper idMapper);
　
　IdMapper get(int id);

    int update(final IdMapper idMapper);

    int delete(int id);

}

然后实现这个接口：

public class IdMapperDaoImpl  extends JdbcDaoSupport implements IdMapperDao {

    private final static Logger log=LoggerFactory.getLogger(IdMapperDaoImpl.class);

    public int insert(final IdMapper idMapper) {
        String sql="insert into idmapper(name, source_id, direct_id, enable) value(?, ?, ?, ?)";
        log.info("IdMapperDao insert:" + idMapper.toString());
        return this.getJdbcTemplate().update(sql, new PreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps) throws SQLException {
                ps.setString(1, idMapper.getName());
                ps.setString(2, idMapper.getSourceId());
                ps.setString(3, idMapper.getDirectId());
                ps.setInt(4, idMapper.getEnable()?1:0);
            }
        });
    }

   @Override
    public IdMapper get(int id) {
        String sql="select * from idmapper where id="+id;
        List<IdMapper> list = this.getJdbcTemplate().query(sql, new RowMapper<IdMapper>() {
            @Override
            public IdMapper mapRow(ResultSet rs, int rowNum) throws SQLException {
                return mapRowToIdMapper(rs);
            }
        });
        if(null == list || list.size() == 0) {
            return null;
        }
        return list.get(0);
    }

    private IdMapper mapRowToIdMapper(ResultSet rs) throws SQLException{
        IdMapper idMapper = new IdMapper();
        idMapper.setId(rs.getInt("id"));
        idMapper.setName(rs.getString("name"));
        idMapper.setSourceId(rs.getString("source_id"));
        idMapper.setDirectId(rs.getString("direct_id"));
        idMapper.setEnable(rs.getInt("enable")==1);
        return idMapper;
    }

    @Override
    public int update(final IdMapper idMapper) {
        //TODO
        return 0;
    }

    @Override
    public int delete(int id) {
        //TODO
        return 0;
    }

}

该类继承了Spring的JdbcDaoSupport类，这能够使得与MySQL数据库进行数据交互的代码简单易写。我们写好了IdMapper的操作类，但是并没有把它关联到数据库。我们在applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="mysqlSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="${mysql.db.url}?useUnicode=true&amp;characterEncoding=UTF-8&amp;failOverReadOnly=false&amp;autoReconnect=true" />
        <property name="username" value="${mysql.db.user}" />
        <property name="password" value="${mysql.db.pwd}" />
        <property name="removeAbandoned" value="true"/>
        <property name= "testWhileIdle" value="false" />
        <property name= "testOnBorrow" value="true" />
        <property name= "testOnReturn" value="false" />
        <property name= "validationQuery" value="select 1" />
    </bean>
    
    <bean id="idMapperDao" class="com.chenyi.learn.dao.impl.IdMapperDaoImpl">
        <property name="dataSource" ref="mysqlSource" />
    </bean>
    
</beans>

Spring容器在创建时会根据applicationContext.xml中的配置创建Bean。我们设置的idMapperDao就是一个Bean，其有一个dataSource属性指向mysqlSource的Bean，也就是说把mysqlSource的Bean注入到idMapperDao这个Bean中。而在mysqlSource的Bean里面我们配置了数据库的链接参数。这里面我们需要了解的是，IdMapperDaoImpl类中并没有dataSource这样的属性，那么是怎么样实现注入的呢？这个问题要源自它的父类JdbcDaoSupport，查看这个类的源代码，我们可以发现：

    /**
     * Set the JDBC DataSource to be used by this DAO.
     */
    public final void setDataSource(DataSource dataSource) {
        if (this.jdbcTemplate == null || dataSource != this.jdbcTemplate.getDataSource()) {
            this.jdbcTemplate = createJdbcTemplate(dataSource);
            initTemplateConfig();
        }
    }

所以，应该是通过set方法实现注入的。

这里面要谈一下面向接口编程的好处。在这里我们提供了Dao的接口，并给了一个实现类。假设有一天我们发现我们存储的数据量已经很大了，MySQL的查询已经非常吃力了。这时候我们考虑使用NoSQL的数据库，例如MongoDB，Hbase等。假如之前我们我们没有用接口，而是直接写了一个IdMapperDaoImpl类，而在很多其他代码里面，我们直接用了这个类及其对象。这时候我们要创建一个新的操作类，假设为IdMapperHbaseDaoImpl，并且我们不得不去修改其他的代码中的实现，把IdMapperDaoImpl都替换成IdMapperHbaseDaoImpl---这会造成很多问题。这种情况就是强依赖。而面向接口编程就能做到弱依赖，解藕。

同样是上面的情景，我们这里实现了一个IdMapperDao的接口，并在applicationContext.xml中为这个接口创建了一个Bean。而在其他的代码里面，我们依赖接口，不依赖具体实现类，使用接口来操作。例如会是以下代码：

@Autowired
private IdMapperDao dao;

这样Spring会把实现了IdMapperDao接口的类注入，也就是applicationContext.xml中配置的Bean。然后假设我们这次要使用IdMapperHbaseDaoImpl了，在这里只需要把对应的Bean改成IdMapperHbaseDaoImpl就行了，代码其他部分完全不用更改。这样，是不是很好啦？这就是面向接口编程的优势，我们甚至只需要更改一行配置代码，就能换掉底层的DAO具体实现，而其他部分完全不用更改。

4. Service对象

按照Java Web的开发方法，一般来说会对业务逻辑进行封装，而这一层一般叫做service。至于为什么要用service进行封装，这可以写很多东西了。但是此处我们直接按照常用的办法来，先创建一个Service服务接口IdMapperService：

public interface IdMapperService {

    IdMapper get(int id);
    int insert(IdMapper idMapper);
    // Other ...TODO

}

再实现这个接口IdMapperServiceImpl：

@Service
public class IdMapperServiceImpl implements IdMapperService {

    @Autowired
    private IdMapperDao dao;

    @Override
    public IdMapper get(int id) {
        return dao.get(id);
    }
    
    @Override
    public int insert(IdMapper idMapper) {
        return dao.insert(idMapper);
    }
    
}

注意到实现代码中使用了@Service注解。这个注解能够告诉Spring，将为这个类创建一个Bean。另外这段代码中还使用了@Autowired注解实现自动装配IdMapperDao对象，这里面体现了前面说的面向接口编程方法，变量dao是IdMapper接口类型，具体对象由@Autowired装配我们在xml中配置的Bean。Service实现里面很简单，就做个演示，而一般常见的业务里面，Service是相当复杂的，例如使用Service封装事务。

5. Controller

终于到了最后一步Controller，我们自定义一个IdMapperController：

@Controller
@RequestMapping("/mapper")
public class IdMapperController {

    @Autowired
    private IdMapperService service;

    @RequestMapping("get")
    @ResponseBody
    public IdMapper get(@RequestParam int id) {
        return service.get(id);
    }

}

写了一个简单的Controller代码，主要通过id获取IdMapper对像。然后我们通过本地测试和URL访问，得到下面的结果：

返回Json

解释一下这部分代码。@Controller注解会告诉Spring也要为这个类生成Bean。@RequestMapping("/mapper")告诉Spring该类的访问URL注册到/mapper。而在这个控制器类中，我们用自动注入的方法注入了Service对像。不像在Service中注入DAO的方式一样---我们在xml声明DAO的Bean，却没有在xml中声明Service的Bean，原因是Service的代码我们使用了@Service注解，它会自动为Service生成Bean，就无需在xml中配置了。

@ResponseBody注解会将返回对象解析成json格式，这也是我们在浏览器中请求，最后会返回json的缘故。@RequestParam注解会将请求URL中的参数匹配到函数中的参数，也就是说我们无需写request.getAttribute("id")，就能直接获取参数id的值，这个注解帮助我们搞定这些功能。只能说有了Spring AOP，真是方便多了。

6. 总结

前前后后花了三个周末的下午总算完成了这三篇练习。作为一个刚入Java Web坑的 Pythonista，感觉Java文化真是博大精深。语言的不同特征，其相关技术栈也很不一样的。例如这个小项目，用Python的话，使用Flask框架再加上sqlalchemy插件，一个小时内就能弄出来，但是用Java的话……

无意批评Java语言，Java的世界很有趣，我现在领略不深，以后我会更深入学习，不限于语言，技术栈，构建方法，框架，有趣的开源项目……当然，Python我也会继续学习，动态脚本语言在某些方面优势实在是明显的，更不用说Python这阵子在机器学习，数据分析领域的火热啦。总之，要掌握一门面对对象的语言（Java），也要掌握好脚本语言（Python/Shell/Js），熟练掌握编程语言这工具，做起事情来才得心应手。