Spring框架2:程序间的耦合和解耦

Day1
image-20200217205852847
image-20200217205852847
image-20200217232030824
image-20200217232030824
SpringMVC是表现层的框架，MyBatis是持久层框架

Spring是EE开发的一站式框架：有EE开发每一层的解决方案。以IOC（反转控制）和AOP（面向切面编程)为内核，同时提供了展现层Spring MVC赫尔持久层Spring JDBC等企业级应用技术，是使用最多的JAVA EE开源框架

WEB:SpringMVC

Service：Bean管理，Spring声明式管理

DAO层：Jdbc模板、ORM模块

Spring的优点：

轻量，方便解耦，简化开发
控制反转（Ioc）
面向切面 (AOP)
声明式事务的支持
方便程序的测试
可以集成其他框架
降低Java EE API使用难度（封装了）
Spring:

docs：开发规范与API
libs：SPring的开放.jar包和源码
Schema:配置文件的约束
image-20200217233554182
image-20200217233554182
core container:是spring的IOC部分，所有的spring应用都要基于这个核心容器

程序间的耦合和解耦
用一个例子来说明程序的耦合

package com.jiading.jdbc;

import java.sql.*;

扫描二维码关注公众号，回复： 9425476 查看本文章

public class JDBCDemo1 {
/
用JDBC来讲解程序的耦合
这里举的是程序间的依赖关系的例子(类之间的依赖、方法间的依赖）
解耦：降低程序间的依赖关系
/
public static void main(String[] args) throws SQLException, ClassNotFoundException {
//1.注册驱动
//在编译期就要依赖其他的程序，它的依赖性是很差的
//实际开发时，应该做到：编译期不依赖，运行期才依赖
//解决思路：
/
使用反射来创建对象，避免使用new关键词
读取配置文件来获取要创建的对象全限定类名
/
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Class.forName("com.mysql.jdbc.Driver");
//2. 获取连接
Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/jd_learning","root","jd5521880");
//3. 获取操作数据库的预处理对象
PreparedStatement pstm=conn.prepareStatement("select * from account");
//4. 执行SQL，得到结果集合
ResultSet rest=pstm.executeQuery();
//5. 遍历结果集合
while(rest.next()){
System.out.println(rest.getString("name"));
}
//6. 释放资源
rest.close();
pstm.close();
conn.close();
}
}
使用工厂设计模式进行解耦
enter description here
enter description here
这是标准的工厂设计模式模板，接口和实现类分开，可以参考下:
IAccountDAO:

package com.jiading.dao;
/
账户的持久层接口
/
public interface IAccountDAO {
/
模拟保存账户
/
void saveAccount();
}
AccountDAOImpl:

package com.jiading.dao.impl;

import com.jiading.dao.IAccountDAO;

public class AccountDAOImpl implements IAccountDAO {
/
模拟保存
/
public void saveAccount() {
System.out.println("保存了账户");
}
}
IAccountService:

package com.jiading.service;

public interface IAccountService {
/
模拟保存账户
/
void saveAccount();
}
AccountServiceImpl：
package com.jiading.service.impl;

import com.jiading.dao.IAccountDAO;
import com.jiading.dao.impl.AccountDAOImpl;
import com.jiading.factory.BeanFactory;
import com.jiading.service.IAccountService;

/
账户的业务层实现类
/
public class AccountServiceImpl implements IAccountService {
//new使得代码有依赖性，独立性差，需要随着依赖的对象的修改而修改
//private IAccountDAO accountDAO = new AccountDAOImpl();

//可以修改为:
private IAccountDAO accountDAO = (IAccountDAO)BeanFactory.getBean("accountDao");
public void saveAccount() {
accountDAO.saveAccount();
}
}

Client:
```java
package com.jiading.ui;

import com.jiading.factory.BeanFactory;
import com.jiading.service.IAccountService;
import com.jiading.service.impl.AccountServiceImpl;

/
模拟一个表现层，用于调用业务层
/
public class Client {
public static void main(String[] args) {
//new产生了依赖关系，使得代码的独立性差
//IAccountService as=new AccountServiceImpl();

    //可以改造为:
    IAccountService as= (IAccountService)BeanFactory.getBean("accountService");
    as.saveAccount();
}

}
BeanFactory:

package com.jiading.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;

/*
一个Bean对象的工厂
Bean:在计算机英语中，有可重用组件的含义
JavaBean > 实体类，javabean是用java语言编写的可重用组件
它就是创建我们的service和dao对象的

需要一个配置文件来配置service和dao
配置的内容：全限定类名和对应的唯一标志
配置文件可以是xml或者是properties

通过读取配置文件中配置的内容，反射创建bean对象
*/
public class BeanFactory {
//定义一个Properties对象
private static Properties props;

//定义一个Map,用于存放我们要创建的对象，我们把它称之为容器
private static Map<String,Object> beans;

//使用静态代码块为Properties对象赋值
static {
//还是用了new关键字，但是这次依赖的是Java中的模块而不是我们自己写的了，这就是进步
//依赖只能降低而不能消除，不能在编程时候一个new关键字不用

 try {
     //1.实例化对象
     props = new Properties();
     //获取properties文件的流对象
     //在resources下的文件在部署时会被放置在根路径下，所以不需要写包名
     InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
     props.load(in);

     beans=new HashMap<String, Object>();
     Enumeration keys = props.keys();
     //遍历枚举
     while(keys.hasMoreElements()){
         String key=keys.nextElement().toString();
         //根据key获取value
         String beanPath=props.getProperty(key);
         //反射创建对象（也就是在初始化环节中在容器中分别创建一个对象以供之后调用，也就是单例模式
         Object value=Class.forName(beanPath).newInstance();
         //存入容器，以供调用
         beans.put(key,value);
     }

 } catch (IOException e) {
     throw new ExceptionInInitializerError("初始化properties失败");
 } catch (IllegalAccessException e) {
     e.printStackTrace();
 } catch (InstantiationException e) {
     e.printStackTrace();
 } catch (ClassNotFoundException e) {
     e.printStackTrace();
 }

}

/
根据Bean的名称获取bean对象
/
public static Object getBean(String beanName) {
/Object bean=null;
try {
String beanPath = props.getProperty(beanName);
bean = Class.forName(beanPath).newInstance();
}catch (Exception e){
e.printStackTrace();
}/
//有了容器后，就有了更方便的getBean方法

 return beans.get(beanName);

}
}
bean.properties:

accountService=com.jiading.service.impl.AccountServiceImpl
accountDao=com.jiading.dao.impl.AccountDAOImpl
现在我们正式使用spring框架，由spring创建框架。这里的配置文件就选择xml

Spring框架2:程序间的耦合和解耦

猜你喜欢