如果你想开发一个应用(1-9)

上一章的结尾，我们看到现有的代码虽然经过了一些改进，但仍然有很多坏味道，首当其冲的就是Controller太厚了，Controller应该仅仅作为一个控制器使用，要尽可能的薄。这时候，上一章里提到过的IOC和DI华丽登场了.

控制反转

控制反转简单说就一句话，就是把程序资源的管理权由互相使用的双方的代码反转到第三方容器。即一般来说，对象的创建和销毁，使用都由用户有代码进行直接控制，而现在则由容器(Spring框架)来控制，这样可以最大限度的减少类的耦合度，比如说无论，一个对象的new是避免不了的，而控制反转则可将这些也交给容器，即各种类彻底的脱离直接联系。

提到控制反转，就不能不提依赖注入，可以说依赖注入就是控制反转的目的之一，即当一个对象需要另一个对象实力的时候，有容器根据这个实例所依赖的实例而注入进去，这种对象之间互相依赖的情况不在由自己管理。

貌似很晦涩，下面我们依然使用注解的方式，先对一部分代码实现控制反转和依赖注入。

用户服务

从最简单的地方开始，注意代码中的一部分：

UserDao userDao =new UserDao();
User user=null;
//获取用户
user=userDao.getUserByName(name);
if(null==user){
    //新用户
    user=new User();
    user.setName(name);
    user.setId(userDao.save(user));
}

这部分代码与现有的业务有关系么？他所需要做的，其实就是查询用户，有则返回userId，没有则创建一个用户并返回存储到db中后的自增长userId。接下来就按照面向接口编程的方式一步步来重构这段代码。

既然是用户服务，那么首先创建一个service包，然后在里边创建一个UserService的接口，接口目前只有一个方法，就是getUserByName,代码如下：

public interface UserService {
    User getUserByName(String username);
}

既然有了接口，那么就会想到接口的实现。在理论上，我们的Controller层并不关心实现方式，只知道使用这个接口定义的功能就可以了，所以，将实现放在service的下级包，即创建包service.impl,然后在包内创建类UserServiceImpl,此类代码如下：

@Service
public class UserServiceImpl implements UserService  {
    public User getUserByName(String username) {
        UserDao userDao =new UserDao();
        User user=null;
        //获取用户
        user=userDao.getUserByName(username);
        if(null==user){
            //新用户
            user=new User();
            user.setName(username);
            user.setId(userDao.save(user));
        }
        return user;
    }
}

注意@Service注解，这代表着此类为一个服务组件，目前Spring中定义了多种组件，大部分可以互相替换，小部分有自己独特的功能，但为了语义上的方便以及代码的可读性，还是建议使用推荐的注解：

• @Service：定义一个业务层的组件
• @Controller：定义一个控制器层的组件
• @Repository：定义一个DB访问层的组件
• @Component：组件，当组件不好归类时可以使用此注解

此时bean的默认名为类名首字母小写，可以使用参数类现实确定bean名，如：

@Service("beanName")    

若此接口有多个实现，并且实现均为组件，可以再调用处通过注解@Qualifier来显式来决定使用哪一个组件，如：

@Autowired
@Qualifier("beanName")
private UserService userService;

用土土的方法运行测试一下，和之前一样，就不在截图，然后删除之前的beanName。将Todo的调用也增加一个服务，并修改代码，做到controller与dao层解耦，控制器源码如下：

@Controller
public class TodoController {
    @Autowired
    private UserService userService;
    @Autowired
    private TodoService todoService;
    @RequestMapping(value ="/todos/{name}" ,method = RequestMethod.GET)
    public String home(@PathVariable String name, HttpServletRequest request){
        User user=userService.getUserByName(name);
        
        List<Todo> list= todoService.getTodoByUserId(user.getId());
        
        request.setAttribute("todos",list);
        request.setAttribute("userid",user.getId());
        return "todos";
    }
    @RequestMapping(value ="/todos" ,method = RequestMethod.POST)
    public String home(HttpServletResponse response, Todo todo) throws IOException {
        todoService.save(todo);
       
        User user = userService.get(todo.getUserId());
        
        return "redirect:/todos/"+user.getName();
    }
}

代码是不是清爽了许多，之后，业务上的变更完全可以再service层消化掉，这是service的两个接口代码如下：

public interface UserService {
    User getUserByName(String username);
    User get(int id);
}


public interface TodoService {
    void  save(Todo todo);
    List<Todo> getTodoByUserId(int userId);
}

然后是两个实现类：

@Service
public class UserServiceImpl implements UserService  {
    public User getUserByName(String username) {
        UserDao userDao =new UserDao();
        User user=null;
        //获取用户
        user=userDao.getUserByName(username);
        if(null==user){
            //新用户
            user=new User();
            user.setName(username);
            user.setId(userDao.save(user));
        }
        return user;
    }

    public User get(int id) {
        UserDao userDao =new UserDao();
        return userDao.get(id);
    }
}


@Service
public class TodoServiceImpl implements TodoService {
    public void save(Todo todo) {
        TodoDao todoDao=new TodoDao();
        todoDao.save(todo);
    }

    public List<Todo> getTodoByUserId(int userId) {
        TodoDao todoDao=new TodoDao();
        return todoDao.getTodoByUserId(userId);
    }
}
    

啊哈，坏味道又出现了，其实这时候我猜你一定想到了，对将dao层页一样的组件化。

仓储组件

有了现有的经验，其实是一件再简单不过的事了，首先将dao包内的两个类改为接口，并创建实现包，最终两个接口的代码如下：

public interface TodoDao {
    public List<Todo> getAll();
    public List<Todo> getTodoByUserId(int userId);
    public void save(Todo todo);
}

public interface UserDao {
    public User getUserByName(String name);
    public User get(int id);
    public int save(User user);
}

然后服务层的代码就变为下面这样了：

@Service
public class UserServiceImpl implements UserService  {
    @Autowired
    private UserDao userDao;
    public User getUserByName(String username) {
        User user=null;
        //获取用户
        user=userDao.getUserByName(username);
        if(null==user){
            //新用户
            user=new User();
            user.setName(username);
            user.setId(userDao.save(user));
        }
        return user;
    }
    public User get(int id) {
        return userDao.get(id);
    }
}


@Service
public class TodoServiceImpl implements TodoService {

    @Autowired
    private TodoDao todoDao;
    public void save(Todo todo) {
        todoDao.save(todo);
    }

    public List<Todo> getTodoByUserId(int userId) {
        return todoDao.getTodoByUserId(userId);
    }
}

然后是dao层实现类的代码（只贴user部分）：

package com.niufennan.jtodos.dao.impl;

import com.niufennan.jtodos.dao.UserDao;
......

@Repository
public class UserDaoImpl implements UserDao{
    public User getUserByName(String name){
        Connection connection= null;
        PreparedStatement statement=null;
        ResultSet resultSet=null;
        List<Todo> list=new ArrayList<Todo>();
        try{
            connection = DatabaseHelper.getConnection();
            statement= connection.prepareStatement("select * from users where name=?");
            statement.setString(1,name);
            resultSet=statement.executeQuery();
            if (resultSet.next()){
                User user=new User();
                user.setId(resultSet.getInt("id"));
                user.setName(resultSet.getString("name"));;
                return user;
            }
        }catch (SQLException ex){
            new RuntimeException(ex);
        }
        finally {
            DatabaseHelper.close(resultSet,statement,connection);
        }
        return null;
    }
    public User get(int id){
        Connection connection= null;
        PreparedStatement statement=null;
        ResultSet resultSet=null;
        List<Todo> list=new ArrayList<Todo>();
        try{
            connection = DatabaseHelper.getConnection();
            statement= connection.prepareStatement("select * from users where id=?");
            statement.setInt(1,id);
            resultSet=statement.executeQuery();
            if (resultSet.next()){
                User user=new User();
                user.setId(resultSet.getInt("id"));
                user.setName(resultSet.getString("name"));;
                return user;
            }
        }catch (SQLException ex){
            new RuntimeException(ex);
        }
        finally {
            DatabaseHelper.close(resultSet,statement,connection);
        }
        return null;
    }
    public int save(User user){
        Connection connection=null;
        PreparedStatement statement=null;
        ResultSet resultSet=null;
        try {
            connection = DatabaseHelper.getConnection();
            statement=connection.prepareStatement("INSERT INTO users(name) VALUES (?);", Statement.RETURN_GENERATED_KEYS);
            statement.setString(1,user.getName());
            statement.executeUpdate();
            resultSet=statement.getGeneratedKeys();
            //获取自增长Id
            if(resultSet.next()){
                return resultSet.getInt(1);
            }else{
                return -1;
            }
        }catch (SQLException ex){
            throw  new RuntimeException(ex);
        }finally {
            DatabaseHelper.close(null,statement,connection);
        }
    }
}

我之所以最后在贴出dao实现层，也就是两个仓储组件的代码，就是因为，怎么说呢，他的味道依然很差，但貌似还没有什么好办法，因为使用jdbc就是要这么写，并且可以看到，其中的有效代码一个方法中也就是一两行，剩下的大部分都是对jdbc的管理代码，我们不是应该多关注业务么？需要关注这些模板代码么？幸好框架给出了解决方案，具体解决方法下一章在进行实现。

截止到本章的源码：github(1-9)