Spring基础入门配置及原理

最新推荐文章于 2021-09-20 13:56:50 发布

weixin_42686300

最新推荐文章于 2021-09-20 13:56:50 发布

阅读量121

点赞数

文章标签： Spring java 学习 spring spring基础

本文链接：https://blog.csdn.net/weixin_42686300/article/details/84234016

版权

Spring学习第一天

单词:
golbal :全体的
Annotation :注解
Application:应用

1.简单介绍spring框架
spring是一个一站式(表现层,业务层,持久层),轻量级,开源的框架

2.能够描述出spring的IOC容器
IOC : 控制反转
IOC:的作用:
消减计算机程序的耦合,(解除我们代码中的依赖关系)
IOC的本质:对象不是自己来new 而是交给Spring来关系
容器:spring用来存放对象的map集合
接口管理了容器,我们把这些接口叫做bean工厂,也叫容器
BeanFactory是顶层接口
其中ApplicationContext 非常常用
ApplicationContext的三个常用实现类：
* ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
* FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）
* AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。

什么是控制反转(或依赖注入) ?
控制反转(IoC=Inversion of Control)IoC，用白话来讲，就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在：(依赖)控制权由应用代码中转到了外部容器，控制权的转移，是所谓反转。
IoC还有一个另外的名字：“依赖注入 (DI=Dependency Injection)” ，即由容器动态的将某种依赖关系注入到组件之中 ,案例：实现Spring的IoC

使用配置文件来读取Dao和service层
创建一个工厂类,使用静态代码块,每次调用者拿对象都会是一个新的对象,是多例的
在这里插入图片描述

 public class BeanFactory {
        private static Properties properties;
        static {
                //读取配置文件
            properties = new Properties();
            try {
                properties.load(BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties"));
            } catch (IOException e) {
                throw new ExceptionInInitializerError("初始化失败");
            }
        }
        /**
         * 根据BeanName名称获取Bean对象
         * @param BeanName
         * @return
         */
        public static Object getBean(String BeanName)  {
            String namePath = properties.getProperty(BeanName);
            Object  bean = null;
            try {
                bean = Class.forName(namePath).newInstance(); //每次都会调用默认构造方法创建新的对象
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return bean;
        }

使用map集合来存储反射对象,调用者调取方法就会获得map集合中的对象,每次拿到的都是同一个对象;是单例的

public class BeanFactory {
    private static Properties properties;
    private static Map<String,Object> beans;
    static {
            //读取配置文件
        properties = new Properties();
        try {
            properties.load(BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties"));
            beans = new HashMap<String, Object>();
            Enumeration<Object> keys = properties.keys();
            while (keys.hasMoreElements()){
                String key = (String) keys.nextElement();
                String values = properties.getProperty(key);
                Object o = Class.forName(values).newInstance();
                beans.put(key,o);
            }
        } catch (IOException e) {
            throw new ExceptionInInitializerError("初始化失败");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    /**
     * 根据BeanName名称获取Bean对象
     * @param BeanName
     * @return
     */
    public static Object getBean(String BeanName) {
      return  beans.get(BeanName);
    }

使用Spring IOC核心容器默认是单例的

第一步:在pom.xml中引入

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
第二步:在bean.xml中配置头部

<?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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="accountService" class="cn.itcast.service.impl.AccountServiceImpl">
</bean> </beans>

第三步:在主方法使用:

ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); //读取配置文件
    AccountServiceImpl accountService = context.getBean("accountService", AccountServiceImpl.class);//对应上面bean标签的id
    accountService.saveAccount();//使用方法

ApplicationContext的三个常用实现类：
* ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
* FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(必须有访问权限）
* AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。

创建对象的三种方式:

    第一种：最常用，推荐使用的
 		<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" />
  	第二种：使用普通工厂中的方法创建对象
  		<bean id="instanceFactory" class="com.itheima.factory.InstanceFactory"></bean>
  		<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
  	第三种：使用工厂中的静态方法创建对象
    	<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="getAccountService"></bean>

对象创建的细节及作用范围
**作用范围：**单例（Spring默认创建的对象就是单例）、多例
生命周期：
单例生命周期与容器同在
多例使用的时候创建对象，最后对象被垃圾回收器回收

什么是依赖注入?
依赖关系的维护：就称之为依赖注入。
依赖注入能注入哪些数据?
能注入的数据：有三类
1. 基本类型和String
2.其他bean类型（在配置文件中或者注解配置过的bean）
3.复杂类型/集合类型
注入的方式有哪几种?
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供

使用构造函数注入

<bean id="accountService" class="cn.itcast.service.impl.AccountServiceImpl">
    <constructor-arg name="name" value="小明"></constructor-arg>
    <constructor-arg name="age" value="18"></constructor-arg>
    <constructor-arg name="brithday" ref="row"></constructor-arg>
</bean>

<bean id="row" class="java.util.Date"></bean> //读取限定类名,反射一个对象,并且存储在spring核心容器中
构造函数注入：
标签中的属性
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
name：用于指定给构造函数中指定名称的参数赋值常用的
=以上三个用于指定给构造函数中哪个参数赋值=
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象

    优势：
        在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
    弊端：
        改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

2).使用set方法注入

<!--构造方法注入-->
<bean id="accountService" class="cn.itcast.service.impl.AccountServiceImpl">
   <property name="age" value="18"></property>
   <property name="name" value="小明"></property>
   <property name="brithday" ref="row"></property>
</bean>

<bean id="row" class="java.util.Date"></bean> //读取限定类名,反射一个对象,并且存储在spring核心容器中

set方法注入更常用的方式
标签的属性
name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
优势：
创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

3).复杂类型的注入/集合类型的注入,用于给List结构集合注入的标签：
list array set
用于个Map结构集合注入的标签:
map props
结构相同，标签可以互换

<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
    <property name="myStrs">
        <set>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </set>
    </property>

    <property name="myList">
        <array>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </array>
    </property>

    <property name="mySet">
        <list>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </list>
    </property>

    <property name="myMap">
        <props>
            <prop key="testC">ccc</prop>
            <prop key="testD">ddd</prop>
        </props>
    </property>

    <property name="myProps">
        <map>
            <entry key="testA" value="aaa"></entry>
            <entry key="testB">
                <value>BBB</value>
            </entry>
        </map>
    </property>
</bean>