解耦性

注意：创建文件要赋予权限：如何给文件赋权

UserDao 接口

package cn.javabs.dao;

/**
 * 用户的持久层接口设计
 */
public interface UserDao {
    /**
     * 模拟添加方法
     *
     * 按照正规逻辑说， 以下方法是错误的 因为没有参数
     */
    void addUser();
}

UserDaoImpl 继承的实现类

package cn.javabs.dao.impl;

import cn.javabs.dao.UserDao;

public class UserDaoimpl implements UserDao {

    /**
     * 模拟添加方法，逻辑是错误的 ，因为没有参数
     */
    @Override
    public void addUser() {
        System.out.println("用户添加成功");
    }
}

service 接口

package cn.javabs.service;

/**
 * 用户的业务逻辑层
 */
public interface UserService {
    /**
     * 模拟添加方法
     *
     * 按照正规逻辑说， 以下方法是错误的 因为没有参数
     */
    void userAdd();

}

UserServiceImpl 继承的实现体

package cn.javabs.service.impl;

import cn.javabs.dao.UserDao;
import cn.javabs.dao.impl.UserDaoimpl;
import cn.javabs.service.UserService;

public class UserServiceImpl implements UserService {
       UserDao ud= new UserDaoimpl();
    /**
     * 模拟添加方法，逻辑是错误的 ，因为没有参数
     */
    @Override
    public void userAdd() {
        System.out.println("添加成功");
    }
}

MyTest 测试

package cn.javabs.test;

import cn.javabs.factory.BeanFactory;
import cn.javabs.service.UserService;
import org.junit.Test;

/**
 * 模拟 Servlet
 */
public class MyTest {

    @Test
    public  void  fun()  {
//        UserService u = new UserServiceImpl();
        for (int i = 0;i <5; i++) {
            UserService us = (UserService) BeanFactory.getBean("userService");
            System.out.println(us);
//                    us.userAdd();
        }
    }
}

factory 工厂类

package cn.javabs.factory;

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

/**
 * 创建对象的一个工厂
 */
public class BeanFactory {
    static  Properties p;
    static {
        try {
        InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
         p = new Properties();
         p.load(is);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据bean方法 去获取bean对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName)  {
        Object bean =null;

        String beanPath = p.getProperty(beanName);
//        System.out.println("beanPath:"+beanPath);

        Class<?> clazz = null;
        try {
            clazz = Class.forName(beanPath);
            bean = clazz.newInstance();// 每一次多会调用默认的构造方法
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

        return bean;
    }
}

BeanFactory文件

userService=cn.javabs.service.impl.UserServiceImpl
userDao.=cn.javabs.dao.impl.UserDaoimpl

运行后的结果：

多列：每一次执行多会创建新的对象，因为哈希值不同（内存的地址值）

每一次执行都访问一次配置文件，共访问了五次

单列：把访问的地址值放在一个集合中每一次都从这个集合里去取。
userDao 接口

package cn.javabs.dao;

/**
 * 用户的持久层接口设计
 */
public interface UserDao {
    /**
     * 模拟添加方法
     *
     * 按照正规逻辑说， 以下方法是错误的 因为没有参数
     */
    void addUser();
}

UserDaoImp

package cn.javabs.dao.impl;

import cn.javabs.dao.UserDao;

public class UserDaoimpl implements UserDao {

    /**
     * 模拟添加方法，逻辑是错误的 ，因为没有参数
     */
    @Override
    public void addUser() {
        System.out.println("用户添加成功");
    }
}

Userservice

package cn.javabs.service;

/**
 * 用户的业务逻辑层
 */
public interface UserService {
    /**
     * 模拟添加方法
     *
     * 按照正规逻辑说， 以下方法是错误的 因为没有参数
     */
    void userAdd();

}

UserserviceImpl

package cn.javabs.service.impl;

import cn.javabs.dao.UserDao;
import cn.javabs.dao.impl.UserDaoimpl;
import cn.javabs.service.UserService;

public class UserServiceImpl implements UserService {
       UserDao ud= new UserDaoimpl();
    /**
     * 模拟添加方法，逻辑是错误的 ，因为没有参数
     */
    @Override
    public void userAdd() {
        System.out.println("添加成功");
    }
}

bean.properties

userService=cn.javabs.service.impl.UserServiceImpl
userDao.=cn.javabs.dao.impl.UserDaoimpl

MyTest

package cn.javabs.test;

import cn.javabs.factory.BeanFactory;
import cn.javabs.service.UserService;
import org.junit.Test;

/**
 * 模拟 Servlet
 */
public class MyTest {

    @Test
    public  void  fun()  {
//        UserService u = new UserServiceImpl();
        for (int i = 0;i <5; i++) {
            UserService us = (UserService) BeanFactory.getBeans("userService");
            System.out.println(us);
//                    us.userAdd();
        }
    }
}

factory

package cn.javabs.factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 创建对象的一个工厂
 */
public class BeanFactory {
    static Properties p;
    static Map beans;

    static {
        try {
            InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            p = new Properties();
            p.load(is);

            beans = new HashMap<>();

            Enumeration<Object> keys = p.keys();

            // 遍历枚举
            while (keys.hasMoreElements()) {
                String key = keys.nextElement().toString();// 枚举对象  下一个元素获取一个了，且又在循环之内
                String beanPath = p.getProperty(key);


                Object value = Class.forName(beanPath).newInstance();
                beans.put(key, value);

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }
        /**
         * 根据bean方法 去获取bean对象
         * @param beanName
         * @return
         */

        public static Object getBean(String beanName){
            Object bean = null;
            String beanPath = p.getProperty(beanName);
            System.out.println("beanPath:" + beanPath);

            try {
                Class<?> clazz = Class.forName(beanPath);
                bean = clazz.newInstance();// 每一次多会调用默认的构造方法
                return bean;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }


        }


        public static Object getBeans (String beanName){
            return beans.get(beanName);
        }
    }

运行后的结果

![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/1973c50f3344babe769eaebc698c3429.png

地址值一样.
不用程序员自己写程序通过一些配置程序自己调用，这里是通过Factory （工厂）调用 来配置的，降低耦合是切面翻转（IOC）通过一些工具程序自己调用创建，不需要程序员创建对象，来降低耦合性，提供代码的利用率。

出现的错误：

说我这个路径写错了，没有找到这个路径
没有改的路径我是这样写的

改好的

在工厂（Factory）里出现方法一致错，我在上一次的方法结束少写了一个方法，同时上一个只能定义为静态，不能用方法写这一点我还是很疑惑的，