Spring_day01

Spring

1.简介

Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。

2.Spring的优势

1.方便解耦，简化开发

2.AOP 编程的支持

3.声明式事务的支持

4.方便程序的测试

5.方便集成各种优秀框架

6.降低 JavaEE API 的使用难度

7.Java 源码是经典学习范例

3.Spring体系结构

 

 

4.程序的耦合

1.耦合：程序间的依赖关系（包括类之间的依赖和方法间的依赖）

2.解耦：降低程序间的依赖关系

　　　　实际开发中：要做到编译期不依赖，运行时才依赖

3.解耦的思路：

第一步：使用反射来创建对象，而避免使用new关键字

第二步：通过读取配置文件来获取创建对象的全限定类名

业务层通常代码实现：

1.持久层：　

package com.itheima.dao;

//持久层接口
public interface IAccountDao {

    void saveAccount();
}

　

package com.itheima.dao.impl;
import com.itheima.dao.IAccountDao;

//持久层接口实现类
public class AccountDaoImpl implements IAccountDao {
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

　　2.业务层：

package com.itheima.service;
//业务层的接口

public interface IAccountService {
    void saveAccount();
}

　　

package com.itheima.service.impl;

import com.itheima.dao.IAccountDao;
import com.itheima.dao.impl.AccountDaoImpl;
import com.itheima.service.IAccountService;

//账户的业务层实现类
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao= new AccountDaoImpl();//业务层调用持久层

    public void saveAccount() {

        accountDao.saveAccount();

    }
}

3.表现层：

package com.itheima.ui;
import com.itheima.service.IAccountService;
import com.itheima.service.impl.AccountServiceImpl;

//模拟一个表现层，调用业务层
public class Client {
    public static void main(String[] args) {
        IAccountService as = new AccountServiceImpl();//表现层调用业务层
        as.saveAccount();
    }
}

使用工厂模式解耦：

一个创建Bean对象的工厂
Bean：在计算机英语中，有可重用组件的含义
JavaBean:用Java语言编写的可重复组件。
　　javabean > 实体类
它就是创建我们的service和dao的对象的。
　　第一个：需要一个配置文件来配置我们的service和dao
　　　　配置的内容：唯一标识 = 全限定类名（key = value）
　　　　配置文件可以使用xml，也可以properties
第二个：通过读取配置文件内容，反射创建对象

　　1.bean.properties文件：

accountService = com.itheima.service.impl.AccountServiceImpl

accountDao = com.itheima.dao.impl.AccountDaoImpl

　　2.工厂类：

package com.itheima.factory;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class BeanFactory {
    private static Properties props;
    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;
    //使用静态代码块为Properties对象赋值,静态代码块在创建类时执行，且只执行一次
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
}

　　3.实现类修改

　业务层调用持久层: private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao")

　表现层调用业务层:IAccountService as = (IAccountService) BeanFactory.getBean("accountService")

5.IOC

控制反转：把创建对象的权利交给框架是框架的重要特征，并非面向对象编程的专业术语，它包括注入依赖和依赖查找。

IOC的作用：削减计算机程序的耦合，即是解除我们代码中的依赖关系。

Spring中的IOC就是帮我们创建工厂对象，使我们开发功能简化。