Java工厂类：通用工厂的使用2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package com.itheima;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/*
工厂类中：new UserServiceImpl();也出现了耦合

对象的创建方式：
  1.直接调用构造函数 创建对象 UserService userService=new UserServiceImpl()
  2.通过反射方式创建对象 反射可以解耦合
     Class clazz=Class.forName("com.itheima.UserServiceImpl");//获取类对象
     UserService userService=clazz.newInstance();

 */
public class BeanFactory {
    private static Properties env=new Properties();//创建Properties集合

    //读取properties文件
     //通过代码块来读取io避免重复性打开io，并且在程序启动的时候一次性读取想要的内容，可以通过静态代码块
    static{
        try {
            //1.获取IO输入流
            InputStream inputStream = BeanFactory.class.getResourceAsStream("/applicationContext.properties");
            //2.文件内容封装到Properties集合里面 问价当中的key作为将集合的key，文件中的值作为集合的值
            env.load(inputStream);
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
   /*
    //解 SpringTest类的耦合
    public static UserService getUserService(){

        //return new UserServiceImpl();出现耦合

        UserService userService=null;
        try {
            //为解决这个耦合可以把这个全限定名称写到一个配置文件properties里面
            Class clazz=Class.forName(env.getProperty("userService"));//传入全限定名，以后可以换成新的类，也需要手动改变，这里页出现耦合
            userService=(UserService) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return userService;
    }


    //解UserServiceImpl类 的耦合
    public static UserDAO getUserDAO(){
        UserDAO userDAO=null;

        try {
            //为解决这个耦合可以把这个全限定名称写到一个配置文件properties里面
            Class clazz=Class.forName(env.getProperty("userDAO"));//传入全限定名，以后可以换成新的类，也需要手动改变，这里页出现耦合
            userDAO=(UserDAO) clazz.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return userDAO;
    }

    */

    //发现以上代码出现大量重复代码，可以通过创建一个通用的方法来解耦合，就可以不用重复创建类似的方法
    //通用工厂方法
    public static Object getBean(String key){
        Object ret=null;
        try {
            Class clazz=Class.forName(env.getProperty(key));//传入全限定名，以后可以换成新的类，也需要手动改变，这里页出现耦合
            ret=(Object) clazz.newInstance();
        } catch(Exception e) {
            e.printStackTrace();
        }
        return ret;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.itheima;

public class UserServiceImpl implements UserService {

    //private UserDAO userDAO=new UserDAOImpl();//这里也会出现耦合，需要工厂类解耦合

    //使用工厂类解耦合
    //private UserDAO userDAO=BeanFactory.getUserDAO();

    //通用工厂方法
    private UserDAO userDAO=(UserDAO) BeanFactory.getBean("userDAO");


    @Override
    public void regist(User user) {
        userDAO.save(user);
    }

    @Override
    public void login(String name, String password) {
        userDAO.queryUserByNameAndPassword(name,password);
    }
}

1
2
3
4
5
package com.itheima;

public class Person {
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#properties 通过key和values 组成
#properties 集合 存储Properties文件内容
#特殊的Map key=value
#通过：
#   Properties.getProperty("userService");获取值


userService=com.itheima.UserServiceImpl
#后续如果需要跟换实现类只需要更改实现类的全限定名称

userDAO=com.itheima.UserDAOImpl

#Person类
person=com.itheima.Person

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package com.itheima;

import org.junit.Test;

public class SpringTest {
    /*
     测试工厂类进行耦合操作：
       有了耦合，可以通过工厂类设计模式：通过工厂类创建对象
     */
    @Test
    public void test1(){
        //把这个接口的实现类编码到了程序当中，就出现偶合：比如以后要换一个实现类的时候，那么测试类也跟着改变
        //要换一个实现类UserServiceImplNew 需要替换下面的代码为UserService userService=new UserServiceImplNew();
        //经过修改后项目经过重新编译和部署，不符合面向对象设计开闭原则：打开扩展，关闭修改
       // UserService userService=new UserServiceImpl();//这一行代码出现耦合

        /*
          通过工厂类： 解决耦合
         */
        UserService userService= (UserService) BeanFactory.getBean("userService");


        userService.login("name","suns");

        User user=new User("suns","123456");
        userService.regist(user);


    }

    @Test
    public void test2(){
        Person person = (Person) BeanFactory.getBean("person");
        System.out.println("Person="+person);
    }
}