JAVA01_30学习总结(Spring入门)

今日内容

1. Spring引入

Spring
    是用来解耦的专用框架和工具,代替普通new的方式,利用反射!

2. 简单工厂模式

简单工厂模式-静态方法工厂模式
    该工厂模式的核心思想就是
        -利用配置文件的键值对特性,利用反射来获取需要的对象,不在使用new的方式,进行解耦!
    步骤
        1)构造方法私有化,让外界不能直接new来访问
        2)书写配置文件,将接口和对应的实现类的全限定名称形成键值对
        3)读取配置文件的内容,放进属性列表,通过获取键来读取值
        4)利用值,通过反射来获取该实现类的对象!
    总结
        -看似步骤书写复杂变多,但是符合书写规范
            -低耦合,高内聚!

package com.szr.factory;
​
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
​
public class beanFactory {
    private beanFactory(){}
​
    public static Object getBean(String pkey){//需要在配置文件中查找的键名称
        try {
            //读取配置文件内容
            InputStream input = beanFactory.class.getClassLoader().
                    getResourceAsStream("bean.properties");
            //创建属性列表
            Properties prop = new Properties();
            //加载读取内容
            prop.load(input);
            //通过键(接口名称)获取对应的值(实现类的全限定名称)
            String str = prop.getProperty(pkey);
            //反射的方式获取实现类的对象
            Class clazz = Class.forName(str);
            Object obj = clazz.newInstance();
            return obj ;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}
​

#配置文件-将接口和对应的实现类的全限定名称对应
userService=com.szr.service.Impl.userServiceImpl

package com.szr.service;
//接口
public interface userService {
    String getMessage();
}

package com.szr.service.Impl;
​
import com.szr.service.userService;
//实现类
public class userServiceImpl implements userService {
    @Override
    public String getMessage() {
        return "拿到信息了" ;
    }
}

package com.szr.springTest;
​
import com.szr.factory.beanFactory;
import com.szr.service.userService;
import org.junit.Test;
//测试类
public class springTest {
    @Test
    public void springtest(){
        //调用工厂方法获取对应的输入的接口的实现类对象
        userService ser = (userService) beanFactory.getBean("userService");
        //调用实现类方法
        String message = ser.getMessage();
        System.out.println(message);
        //拿到信息了
    }
}

简单工厂模式-静态方法工厂模式
    通过dom4j技术解析xml文件获取实现类对象
    步骤
        1)首先配置xml文件
            自定义标签
            跟标签只能有一个
            子标签
                -id:子标签唯一标识,接口首字母小写
                -class:当前接口实现类的全限定名称
        2)构造方法私有化,外界无法通过new来访问
        3)创建解析器对象
        4)解析器读取流内容(xml文件)获取文档对象
        5)通过文档对象获取xml文件中的根节点对象
        6)通过根节点对象调用xpath(xml文件路径语言)中的方法
            获取指定的单个节点
                //  -   不分层级关系选中的节点
                bean    -   选中的bean标签
                []  -   xxx的bean标签
                @   -   指定属性名称
        7)获取当前实现类的全限定名称
        8)创建当前实现类实例(获取对象)

<?xml version="1.0" encoding="UTF-8" ?>
<!--唯一根节点标签-->
<beans>
    <!--子标签 id唯一标识  class全限定名称  类似于键值对-->
    <bean id="userService" class="com.szr.service.Impl.userServiceImpl"></bean>
    <!--子标签可以有很多...-->
</beans>

package com.szr.factory;
​
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
​
import java.io.InputStream;
​
public class beanFactoryXml {
    //构造方法私有化
    private beanFactoryXml(){}
    //提供公共方法来访问,通过dom4j技术来解析xml文件
    public static Object getBeanXml(String beanId){//输入xml文件中唯一标识,来解析对应的内容
        try {
            //创建解析器
            SAXReader reader = new SAXReader();
            //解析类路径,获取文档对象
            //读取xml文件
            InputStream input = beanFactoryXml.class.getClassLoader().getResourceAsStream("bean.xml");
            //解析器读取流内容获取文档对象
            Document document = reader.read(input);
            //通过文档对象获取根节点对象
            Element rootElement = document.getRootElement();
            /*
                通过文档对象调用xpath(xml文件路径语言)的方法
                获取指定的单个节点
                    // -  不分层级关系选中的节点
                    bean   -  选中的bean标签
                    [] -  xxx的bean标签
                    @  -  指定属性名称
            */
            Element element = (Element) rootElement.selectSingleNode("//bean[@id='" + beanId + "']");
            //获取找到的对应的子节点的对应的内容--class中的内容-全限定名称
            String value = element.attributeValue("class");
            //利用全限定名称通过反射创建对象
            Class clazz = Class.forName(value);
            Object obj = clazz.newInstance();
            //返回得到的结果对象
            return obj ;
        } catch (DocumentException | ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

3. Spring方式

Spring方式创建实现类对象
    -便捷快速方便
    步骤
        1)配置xml配置文件-spring版本
        2)创建Spring容器
        3)读取配置文件
        4)创建当前bean对象
        5)调用方法!

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--管理bean对象的创建-->
    <!--配置多个bean标签
        id必须唯一:代表这个class后面类的全限定名称的标书
    -->
    <bean id="userService" class="com.szr.service.Impl.userServiceImp" >
    </bean>
</beans>

@Test
public void SpringTest(){
    //创建spring容器,读取spring.xml文件
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    //创建当前bean对象-底层-通过唯一标识id获取class全限定名称-通过反射创建对象
    userService userservice = (userService) context.getBean("userService");
    //调用方法
    String message = userservice.getMessage();
    System.out.println(message);
    //拿到信息了
}