========
简单工厂
========

1 实体类

/src/main/java/cn/tedu/nofactory/User.java：

public class User {
    private String username;
    private String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
            "username='" + username + '\'' +
            ", password='" + password + '\'' +
            '}';
    }
}

2 数据访问接口及实现

/src/main/java/cn/tedu/nofactory/UserDao.java：

public interface UserDao {
    public void save(User user);
    public User query(String username, String password);
}

/src/main/java/cn/tedu/nofactory/UserDaoImpl.java：

public class UserDaoImpl implements UserDao {
    @Override
    public void save(User user) {
        System.out.println("save(" + user + ")");
    }

    @Override
    public User query(String username, String password) {
        System.out.println("query(" + username + ", " + password + ")");
        return new User(username, password);
    }
}

3 服务接口及实现

/src/main/java/cn/tedu/nofactory/UserService.java：

public interface UserService {
    public void register(User user);
    public User login(String username, String password);
}

/src/main/java/cn/tedu/nofactory/UserServiceImpl.java：

public class UserServiceImpl implements UserService {
    private UserDao userDao = new UserDaoImpl();
                                       ^
    @Override                          |__直接创建实现类对象，强耦合
    public void register(User user) {
        userDao.save(user);
    }

    @Override
    public User login(String username, String password) {
        return userDao.query(username, password);
    }
}

4 测试用例

/src/test/java/cn/tedu/nofactory/UserServiceTest.java：

class UserServiceTest {                       __直接创建实现类对象，强耦合
    @org.junit.jupiter.api.Test              |
    void testRegister() {                    v
        UserService userService = new UserServiceImpl();
        userService.register(new User("zhangfei", "123456"));
    }

    @org.junit.jupiter.api.Test
    void testLogin() {
        UserService userService = new UserServiceImpl();
        userService.login("zhangfei", "123456");
    }
}

例程：NoFactory

5 工厂类

/src/main/java/cn/tedu/simplefactory/BeanFactory.java：

public class BeanFactory {
    public static UserDao getUserDao() {
        return new UserDaoImpl();
    }

    public static UserService getUserService() {
        return new UserServiceImpl();
    }
}

6 通过工厂创建对象

/src/main/java/cn/tedu/simplefactory/UserServiceImpl.java：

public class UserServiceImpl implements UserService {
    private UserDao userDao = BeanFactory.getUserDao();
                                       ^
    @Override                          |__通过工厂创建实现类对象，弱耦合
    public void register(User user) {
        userDao.save(user);
    }

    @Override
    public User login(String username, String password) {
        return userDao.query(username, password);
    }
}

/src/test/java/cn/tedu/simplefactory/UserServiceTest.java：

class UserServiceTest {                       __通过工厂创建实现类对象，弱耦合
    @org.junit.jupiter.api.Test              |
    void testRegister() {                    v
        UserService userService = BeanFactory.getUserService();
        userService.register(new User("zhangfei", "123456"));
    }

    @org.junit.jupiter.api.Test
    void testLogin() {
        UserService userService = BeanFactory.getUserService();
        userService.login("zhangfei", "123456");
    }
}

例程：SimpleFactory

- 实现类发生变化，只需修改工厂类的代码，使用该类的代码不受影响
- 工厂类依然要通过硬编码直接new出实现类的对象
- 简单工厂只是弱化了耦合，并没有完全解除耦合