01-Spring入门

1- 项目环境(传统)

1.1 SQL数据表结构

-- 创建数据库
create database spring;

-- 显示数据库
show databases;

-- 使用数据库
use spring;

-- 创建客户表
CREATE TABLE `cst_customer` (
  `cust_id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
  `cust_name` varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
  `cust_source` varchar(32) DEFAULT NULL COMMENT '客户信息来源',
  `cust_industry` varchar(32) DEFAULT NULL COMMENT '客户所属行业',
  `cust_level` varchar(32) DEFAULT NULL COMMENT '客户级别',
  `cust_address` varchar(128) DEFAULT NULL COMMENT '客户联系地址',
  `cust_phone` varchar(64) DEFAULT NULL COMMENT '客户联系电话',
  PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

-- 添加客户数据
INSERT INTO `cst_customer` 
VALUES ('1', '美团外卖','网络营销', '互联网', '普通客户','北京市海淀区北四环西路9号','7758258');
INSERT INTO `cst_customer` 
VALUES ('2', '360公司','网络安全', '互联网', '普通客户','北京市朝阳区酒仙桥路6号院','0208888887');
INSERT INTO `cst_customer` 
VALUES ('3', '百度','网络搜索', '互联网', '普通客户','北京朝阳区','389056');
INSERT INTO `cst_customer` 
VALUES ('4', '小米','手机制造', '互联网+', 'VIP','武汉光谷','2267890');
INSERT INTO `cst_customer` 
VALUES ('5', '腾讯','网络广告', '互联网', 'VIP','深圳市南山区','123456');
INSERT INTO `cst_customer` 
VALUES ('6', '华为','电视广告', '高新科技制造业', 'VIP','深圳龙岗','033567');

-- 查询数据库
select * from cst_customer;

1.2 项目目录

​

1.3 导入父依赖（pom.xml）

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.guardwhy</groupId>
    <artifactId>Spring</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!--模块-->
    <modules>
        <module>01_spring_jdbc</module>
    </modules>

    <properties>
        <!-- spring版本 -->
        <spring.version>5.2.9.RELEASE</spring.version>
        <!-- mysql版本 -->
        <mysql.version>5.1.30</mysql.version>
    </properties>

    <dependencies>
        <!--spring 版本-->
        <dependency>
            <groupId>org.springframework </groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--测试依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <!-- mysql数据库依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
    </dependencies>
</project>

1.4 倒入子依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>Spring</artifactId>
        <groupId>cn.guardwhy</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>01_spring_jdbc</artifactId>

</project>

1.5 测试代码(jdbc案例)

存在问题: 代码的耦合度太高了

package cn.guardwhy.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JdbcDemo01 {
    
    
    public static void main(String[] args) {
    
    
        Connection connection = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;
        try {
    
    
            // 1.加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2.创建数据库链接对象
            connection = DriverManager.getConnection("jdbc:mysql:///spring", "root", "root");
            // 3.定义sql语句
            String sql = "select * from cst_customer";
            // 4.创建Statement语句对象
            psmt = connection.prepareStatement(sql);
            // 5.执行操作
            rs = psmt.executeQuery();
            // 6.处理结果集
            while (rs.next()){
    
    
                System.out.println("客户Id:" + rs.getInt("cust_id") + 
                ", 客户名称:" + rs.getString("cust_name"));
            }
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            // 7.释放资源
            try {
    
    
                if(rs != null) rs.close();
                if(psmt != null) psmt.close();
                if(connection != null) connection.close();
            } catch (Exception e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

2- 工厂模式解耦环境

2.1 三层架构图示

​

2.2 项目环境

2.2.1 项目结构

​

2.2.2 配置文件（bean.properties）

CUSTOMERDAO=cn.guardwhy.dao.impl.CustomerDaoImpl
CUSTOMERSERVICE=cn.guardwhy.service.impl.CustomerServiceImpl

2.2.3 BeanFactory代码

package cn.guardwhy.factory;

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

/**
 * 工厂类实现
 */
public class BeanFactory {
    
    
    // 1.声明一个私有的工厂类对象引用
    private static BeanFactory beanFactory;
    // 2.将构造方法私有化
    private BeanFactory(){
    
    

    }
    // 3.通过静态代码块初始化
    // 定义Properties
    private static Properties prop;
    static {
    
    
        // 创建工厂类对象
        beanFactory = new BeanFactory();
        // 创建prop对象,加载属性配置文件
        prop = new Properties();
        InputStream inputStream = BeanFactory.class.getClassLoader().
        getResourceAsStream("bean.properties");
        try {
    
    
            prop.load(inputStream);
        } catch (IOException e) {
    
    
            e.printStackTrace();
            System.out.println("加载属性资源文件,发生异常:" + e.getMessage());
        }
    }

    // 4.提供一个公有的、静态的方法，获取工厂类对象引用
    public static BeanFactory getBeanFactory(){
    
    
        return beanFactory;
    }

    /**
     *  1.通过配置文件，将要创建的目标对象的类型信息，进行配置
     *  2.在工厂类中加载配置文件，通过反射技术实现运行时加载，并创建目标对象
     */
    public Object getBean(String beanName){
    
    
        // 目标对象
        Object result = null;
        // 获取类路径
        String className = prop.getProperty(beanName);
        // 反射技术创建对象
        try {
    
    
            result = Class.forName(className).newInstance();
        } catch (Exception e) {
    
    
            e.printStackTrace();
            System.out.println("运行时创建对象,发生异常:" + className);
        }
        return result;
    }
}

2.2.4 持久层(Dao层)

• dao层接口

package cn.guardwhy.dao;
/**
 * 客户dao接口
 */
public interface CustomerDao {
    
    
    /**
     * 保存客户操作
     */
    void saveCustomer();
}

• dao实现类

package cn.guardwhy.dao.impl;

import cn.guardwhy.dao.CustomerDao;
/**
 * 客户dao实现类
 */
public class CustomerDaoImpl implements CustomerDao {
    
    
    @Override
    public void saveCustomer() {
    
    
        System.out.println("保存客户操作");
    }
}

2.2.5 业务层(Service)

• service接口

package cn.guardwhy.service;
/**
 * 客户service接口
 */
public interface CustomerService {
    
    
    /**
     * 保存客户操作
     */
    void saveCustomer();
}

• service实现类

package cn.guardwhy.service.impl;

import cn.guardwhy.dao.CustomerDao;
import cn.guardwhy.factory.BeanFactory;
import cn.guardwhy.service.CustomerService;
/**
 * 客户service实现类
 */
public class CustomerServiceImpl implements CustomerService {
    
    
    // 从工厂类获取客户dao对象
    private CustomerDao customerDao = (CustomerDao) BeanFactory.getBeanFactory().getBean("CUSTOMERDAO");

    /**
     * 保存客户操作
     */
    @Override
    public void saveCustomer() {
    
    
        customerDao.saveCustomer();
    }
}

2.2.6 表现层(Controller)

• controller

package cn.guardwhy.controller;

import cn.guardwhy.factory.BeanFactory;
import cn.guardwhy.service.CustomerService;

public class CustomerController {
    
    
    public static void main(String[] args) {
    
    
        // 从工厂类获取客户端service对象
        CustomerService customerService = (CustomerService)
         BeanFactory.getBeanFactory().getBean("CUSTOMERSERVICE");
        // 保存客户操作
        customerService.saveCustomer();
    }
}

2.3 工厂模式解耦

工厂就是负责创建对象，并且把对象放到容器中。在实际使用的时候，帮助我们从容器获取指定的对象。此时我们获取对象的方式发生了改变。
原来我们获取对象时，都是采用new的方式，是主动获取。现在我们获取对象时，找工厂要，由工厂创建并且提供给我们，是被动接收
#结论：这种获取对象方式的转变（由原来主动获取，到现在被动接收），我们称它为控制反转。控制反转，即IOC（Inversion Of Control）。

传统获取对象的方式
​

通过工厂模式获取对象的方式
​