spring框架基础01

1.三层架构

1.mvc模式

mvc: web开发中，使用mvc架构模式。m: 数据，V: 视图，C: 控制器。

m数据: 来自数据库mysq|， 来自文件，来自网络

C控制器: 接收请求，调用service对象， 显示请求的处理结果。当前使用servlet作为控制器

v视图: 现在使用jsp，html, CSS, js。显示请求的处理结果， 把m中数据显示出来。

2.三层架构

1.界面层(视图层) :接收用户的请求，调用service， 显示请求的处理结果的。包含了jsp, html, servlet等对象。对应的包controller

2.业务逻辑层:处理业务逻辑，使用算法处理数据的。把数据返回给界面层。对应的是servic包， 和包中的很多的XXXService类。例如: StudentService ，OrderService, ShopService

3.持久层(数据库访问层) :访问数据库,或者读取文件，访问网络。获取数据。对应的包是dao。 dao包中很多的StudentDao, OrderDao, ShopDao等等。

3.代码示例

持久层

持久层接口

/**
 * 持久层接口
 */
public interface IUserDao {
   
    void saveUser();
}

实现持久层接口

/**
 * 实现持久层接口
 */
public class IUserDaoImpl implements IUserDao {
   
    public void saveUser() {
   
        System.out.println("用户保持了");
    }
}

业务层

业务层接口

/**
 * 业务层接口
 */
public interface IUservice {
   

    void SaveAccount() ;
}

业务层接口实现

/**
 * 实现业务层接口
 */
public class IUserviceImpl implements IUservice {
   

    private IUserDao iUserDao;

    /**
     * 调用持久层接口的方法
     */
    public void SaveAccount()  {
   
        //多态创建
        iUserDao = new IUserDaoImpl();
        //调用持久层接口方法
        iUserDao.saveUser();
    }
}

表现层

/**
 * 模拟表现层，调用业务层
 */
public class Client {
   

    public static void main(String[] args)  {
   
        new IUserviceImpl().saveUser();
    }
}

业务逻辑

表现层------(调用)—>业务层------(调用)----->持久层

2.程序耦合

1.程序耦合概述

什么是耦合？耦合就是程序之间的依赖关系，耦合程度高，相互依赖程度高，耦合程度低，相互依赖程度低。

一个程序来说，应当程序相互依赖程度越低越好。

从上面的代码中可以发现代码之间的依赖程度很高

假设IUserviceImpl有错误，IUserviceImpl有错误，那么后面的程序都会有错误。

2.解耦

new创建对象

工厂模式创建对象

工厂模式的具体实现

步骤一：建立一个properties文件，保持我们想要加载类的全限定类名称

步骤二：建立工厂类

public class BeanFactory {
   
    private static Map<String,Object> beans;
    
    private static Properties prop;

    static {
   

        try {
   


            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");

            prop = new Properties();
            prop.load(in);

            beans = new HashMap<String, Object>();

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

            while (keys.hasMoreElements()) {
   
                //取出每个Key
                String key = keys.nextElement().toString();
                System.out.println(key);
                //根据key获取value
                String beanPath = prop.getProperty(key);
                System.out.println(beanPath);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key, value);
            }
        } catch (Exception e){
   
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }


    public static Object getBean(String beanName) throws Exception{
   
        return beans.get(beanName);
    }

}

步骤三：使用工厂创建对象

业务层调用持久层使用

public class IAserviceImpl implements IAservice {
   

    public void SaveAccount() throws Exception {
   
        IAccountDaoimpl accountDao =(IAccountDaoimpl) BeanFactory.getBean("Dao");
        accountDao.SaveAccount();
    }
}

表现层调用业务层使用

public class Client {
   

    public static void main(String[] args) throws Exception {
   
        IAserviceImpl iAserviceImpl =(IAserviceImpl)BeanFactory.getBean("Service");
        iAserviceImpl.SaveAccount();
    }
}

代码分析

3.bean对象

什么是bean：Bean：在计算机英语中，有可重用组件的含义
JavaBean：用java语言编写的可重用组件

bean：是任意实例化对象与其名称相对应的对象(也称组件)

beans容器

是储存对象的容器（对象名称1，实例化对象1），（对象名称2，实例化对象2）…如下图所示

如何才能获得这么一个容器呢？

需要告诉Spring框架：这个类的全限定类名称，以及我们给这个类实例化对象取的名字

3.使用spring的IOC解决程序耦合

1.配置依赖

在项目pom.xml文件中配置如下Spring依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context