Spring基础整理

Spring

1.Spring概述
2.Ioc的概念和作用
3.使用Spring的IOC解决程序耦合
- 3.1如何入门
- 3.2 Spring 基于 XML 的的 IOC 细节

1.Spring概述

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：

反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring

MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多

著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

2.Ioc的概念和作用

方便解耦，简化开发

通过 Spring提供的 IoC容器，可以将对象间的依赖关系交由 Spring进行控制，避免硬编码所造

成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可

以更专注于上层的应用。
是什么是耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调

用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关

系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立

性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。

在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计

应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个

准则就是**
高内聚低耦合 **。
解决方式

就是直接使用配置文件
工厂模式解耦

在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的

方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。

那么，这个读取配置文件，创建和获取三层对象的类就是工厂。
控制反转-Inversion Of Control

Spring基础整理
通过解耦后变成，通过工厂来调用配置文件来生产对象

Spring基础整理
这种被动接收的方式获取对象的思想就是控制反转，它是 spring 框架的核心之一

3.使用Spring的IOC解决程序耦合

3.1如何入门

创建业务层接口和实现类

package com.xiao.dao;

public interface AccountDao {
    /**
     * 保存账户
     */
    public void saveAccount();
}
package com.xiao.dao.impl;

---------------------------------------------------------------------

import com.xiao.dao.AccountDao;

/**
 * @_PackageName:com.xiao.dao.Impl
 * @_ClassName:AccountDaoImpl
 * @_Description:
 * @_Author：笑老二
 * @_data 2020/4/25 13:39
 */
public class AccountDaoImpl implements AccountDao {
    public void saveAccount() {
        System.out.println("用户保存成功");
    }
}

创建持久层接口和实现类

public interface IAccountDao {
  /**
  * 保存账户
  */
    void saveAccount();
}

public class AccountDaoImpl implements IAccountDao {
@Override
  public void saveAccount() {
  System.out.println("保存了账户");
  }
}

配置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">
</beans>

让 spring 管理资源置，在配置文件中配置 service 和和 dao

<!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中
id 属性：对象的唯一标识。
class 属性：指定要创建对象的全限定类名
-->
<!-- 配置 service -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
</bean>
<!-- 配置 dao -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>

测试配置

@Test
    public void springIocTest(){

        //获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        //根据id来获取Bean对象
        AccountService accountService =(AccountService)ac.getBean("accountService");
        AccountDao accountDao = ac.getBean("accountDao", AccountDao.class);
        System.out.println(accountService);
        System.out.println(accountDao);
    }

3.2 Spring 基于 XML 的的 IOC 细节

spring工厂的类结构图

Spring基础整理

Spring基础整理
BeanFactory 和和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。

ApplicationContext 是它的子接口。

BeanFactory 和 ApplicationContext 的区别：

创建对象的时间点不一样。

ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。

BeanFactory：什么使用什么时候创建对象。

ApplicationContext

有三种方式

ClassPathXmlApplicationContext

：

它是从类的根路径下加载配置文件推荐使用这种

FileSystemXmlApplicationContext

：

它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

AnnotationConfigApplicationContext

当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

bean标签

Spring基础整理
生命周期

Spring基础整理

实例化bean的方式

第一种使用默认我无惨构造方法就是例子那种

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/>

<!--
        第三种方式：spring  管理静态工厂- 使用静态工厂的方法创建对象
            使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
            id 属性：指定 bean 的 id，用于从容器中获取
            class 属性：指定静态工厂的全限定类名
            factory-method 属性：指定生产对象的静态方法
        /**
        * 模拟一个静态工厂，创建业务层实现类
        */
-->
    <bean id="accountService" class="com.xiao.factory.StaticFactory" factory-method="createAccountService"/>

package com.xiao.factory;

import com.xiao.service.AccountService;
import com.xiao.service.impl.AccountServiceImpl;

/**
 * @_PackageName:com.xiao.dao.factory
 * @_ClassName:InstanceFactory
 * @_Description:
 * @_Author：笑老二
 * @_data 2020/4/25 16:54
 */
public class StaticFactory {
    public static AccountService createAccountService(){
        return new AccountServiceImpl();
    }
}

<!--
            /**
            * 模拟一个实例工厂，创建业务层实现类
            * 此工厂创建对象，必须现有工厂实例对象，再调用方法
            */

      先把工厂的创建交给 spring 来管理。
      然后在使用工厂的 bean 来调用里面的方法
      factory-bean 属性：用于指定实例工厂 bean 的 id。
      factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
        <bean id="instanceFactory" class="com.xiao.factory.InstanceFactory" />
        <bean id="accountService"
              factory-bean="instanceFactory"
              factory-method="createAccountService"/>

依赖的注入用来维护这个中业务层和持久层的关系，在使用spring之后，就由spring来维护
1. 构造函数的注入

package com.xiao.service.impl;

import com.xiao.service.AccountService;

import java.util.Date;

/**
 * @_PackageName:com.xiao.service.impl
 * @_ClassName:AccountServiceImpl
 * @_Description:
 * @_Author：笑老二
 * @_data 2020/4/25 19:11
 */
public class AccountServiceImpl implements AccountService {
    private int id;
    private String name;
    private Date date ;

    public AccountServiceImpl(int id, String name, Date date) {
        this.id = id;
        this.name = name;
        this.date = date;
    }


    public AccountServiceImpl() {
        System.out.println("对象创建了");
    }

    public void saveAccount() {
        System.out.println("saveAccount方法执行了，"+id+","+name+","+date+",");
    }
}

<bean id="accountService" class="com.xiao.service.impl.AccountServiceImpl">
        <constructor-arg name="id" value="18"/>
        <constructor-arg name="date" ref="now"/>
        <constructor-arg name="name" value="张三"/>
    </bean>
    <bean id="now" class="java.util.Date"/>

set方法的注入

package com.xiao.service.impl;

import com.xiao.service.AccountService;

import java.util.Date;

/**
 * @_PackageName:com.xiao.service.impl
 * @_ClassName:AccountServiceImpl
 * @_Description:
 * @_Author：笑老二
 * @_data 2020/4/25 19:11
 */
public class AccountServiceImpl2 implements AccountService {
    private int id;
    private String name;
    private Date date ;

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    public AccountServiceImpl2() {
        System.out.println("对象创建了");
    }

    public void saveAccount() {
        System.out.println("saveAccount方法执行了，"+id+","+name+","+date+",");
    }
}

<bean id="accountService2" class="com.xiao.service.impl.AccountServiceImpl2">
        <property name="date" ref="now"/>
        <property name="id" value="18"/>
        <property name="name" value="王五"/>
    </bean>

注入集合属性

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。
我们这里介绍注入数组，List,Set,Map,Properties。具体代码如下：
/***/
public class AccountServiceImpl implements IAccountService {
private String[] myStrs;
private List<String> myList;
private Set<String> mySet;
private Map<String,String> myMap;
private Properties myProps;
public void setMyStrs(String[] myStrs) {
  this.myStrs = myStrs;
}
public void setMyList(List<String> myList) {
  this.myList = myList;
}
public void setMySet(Set<String> mySet) {
  this.mySet = mySet;
}
public void setMyMap(Map<String, String> myMap) {
  this.myMap = myMap;
}
public void setMyProps(Properties myProps) {
  this.myProps = myProps;
}
@Override
public void saveAccount() {
  System.out.println(Arrays.toString(myStrs));
  System.out.println(myList);
  System.out.println(mySet);
  System.out.println(myMap);
  System.out.println(myProps);
  }
}

<!-- 注入集合数据
List 结构的：
array,list,set
Map 结构的
map,entry,props,prop
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
<!-- 给数组注入数据 -->
<property name="myStrs">
<set>
  <value>AAA</value>
  <value>BBB</value>
  <value>CCC</value>
</set>
</property>
<!-- 注入 list 集合数据 -->
<property name="myList">
  <array>
    <value>AAA</value>
    <value>BBB</value>
    <value>CCC</value>
  </array>
</property>
<!-- 注入 set 集合数据 -->
<property name="mySet">
  <list>
    <value>AAA</value>
    <value>BBB</value>
    <value>CCC</value>
  </list>
</property>
<!-- 注入 Map 数据 -->
<property name="myMap">
  <props>
    <prop key="testA">aaa</prop>
    <prop key="testB">bbb</prop>
  </props>
</property>
<!-- 注入 properties 数据 -->
<property name="myProps">
  <map>
    <entry key="testA" value="aaa"></entry>
      <entry key="testB">
      <value>bbb</value>
    </entry>
  </map>
</property>
</bean>

Spring基础整理

Spring

1.Spring概述

2.Ioc的概念和作用

3.使用Spring的IOC解决程序耦合

3.1如何入门

3.2 Spring 基于 XML 的的 IOC 细节

继续阅读

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

Ambari介绍和架构原理

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

NOSQL安全攻击

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

Spring基础整理

Spring

1.Spring概述

2.Ioc的概念和作用

3.使用Spring的IOC解决程序耦合

3.1如何入门

3.2 Spring 基于 XML 的 的 IOC 细节

继续阅读

3.2 Spring 基于 XML 的的 IOC 细节