投稿
  1. 极客之音首页
  2. 后端笔记

一篇解决Spring框架所有知识（陆续更新完全）

Java光头强 • • 后端笔记 • 阅读 251

导读：本篇文章讲解 一篇解决Spring框架所有知识（陆续更新完全），希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

这篇博客是我在学习Spring期间，根据自己所学知识，idea项目编辑，以及其他Spring博客总结出这篇博客。

1. spring概述

1.1Spring框架的概述

Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

Spring是于2003 年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE

Development and Design中阐述的部分理念和原型衍生而来。

它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 JavaEE 应用程序开发提供集成的框架。

Spring的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

IOC:控制反转，将创建对象的过程交给spring进行管理

AOP:面向切面，在不修改源代码的情况之下进行代码功能的增强

1.2 Spring框架的优点

1.2.1 方便解耦，简化开发

Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理，这也是IOC的作用。

1.2.2 AOP编程的支持

Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能。

1.2.3 声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无需手动编程。

1.2.4 方便程序的测试

Spring对Junit4支持，可以通过注解方便的测试Spring程序。

1.2.5 方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts2、

Hibernate、MyBatis等）的直接支持。

1.2.6 降低JavaEE API的使用难度

Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

一篇解决Spring框架所有知识（陆续更新完全）

 1.3 Spring IOC容器

        1.3.1 什么是IOC

IOC — Inverse of Control，控制反转，将对象的创建权力反转给Spring框架！

在java当中一个类想要使用另一个类的方法，就必须在这个类当中创建这个类的对象，那么可能会出现如下情况， 比如A类当中创建着B对象，B类当中有C对象，C类当中有A对象，这个如果一个类出了问题，那么可能会导致这个框架出现问题。 Spring 将创建对象的权利给了IOC，在IOC当中创建了ABC三个对象吗，那么我们我们其他的类只需要调用集合， 大大的解决了程序耦合性的问题。

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

解决问题：使用IOC可以解决程序耦合性高的问题。

1.3.2 IOC容器的底层原理

IOC的实现，依赖于以下3门技术

        ① dom4j解析xml文档；

        ② 工厂模式；

        ③ 采用反射设计模式创建对象

首先我们需要讲一下什么是工厂模式

一篇解决Spring框架所有知识（陆续更新完全）

在当前情况之下A类想要调用B类就必须自己在自己的内部新建B类的对象，这样的耦合度太高，那我们如何降低耦合度的呢？

一篇解决Spring框架所有知识（陆续更新完全）

 创建一个工厂类，这样就能够使得A和B的耦合度降低到最小值

1.3.3 实现IOC

那么上边提到的三种技术如何实现IOC的呢？

第一步：xml配置文件，配置创建对象

<bean id="demo" class="com.qcby.service.Demo" />

第二步：创建工厂类

public class DemoFactory {
    //利用dom4j得到name所对应的value值
   public static Demo getDemo() throws Exception {
       //利用dom4j得到name所对应的value值
       String value="class路径";
       //通过反射创建对象
       Class clazz = Class.forName(value);
       //返回并创建demo对象
       return (Demo) clazz.newInstance();
   }
}

通过以上两步，我们基本上就可以得到我们所创建的对象。

1.3.4 IOC(接口)

1.IOC思想是基于IOC容器完成的，IOC的底层就是对象工厂

2.Spring里边提供了IOC容器的实现的两种方式

(1) BeanFactroy：IOC容器是Spring内部的使用接口，不提供给开发人员使用

一篇解决Spring框架所有知识（陆续更新完全）

* BeanFactroy:加载配置文件的时候不会去创建对象，在使用对象的时候才会去创建对象

(2)ApplicationContext:BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员进行使用

一篇解决Spring框架所有知识（陆续更新完全）

 *加载配置文件的时候会把对象创建

1.4 Spring框架的Bean管理

 1.4.1 元素属性

        bean元素:使用该元素描述需要spring容器管理对象
        name属性:给被管理的对象起个名字,获得对象时getBean(“name值”)
        class属性:被管理对象的完整类名
        id属性:与name属性一模一样，名称不可重复，不能使用特殊字符

       name和id之间的一些注意点：

1、配置两个相同的 id 或者 name 都不能通过。
2、如果既配置了 id ，也配置了 name ，则两个都生效。如果id和name都没有指定，则用类全名作为name，如<bean class=”com.stamen.BeanLifeCycleImpl”>,则你可以通过getBean(“com.stamen.BeanLifeCycleImpl”)返回该实例。
3、如果配置基本类的时候，注解和配置文件都使用的时候，注解和配置文件中 name 相同的时候， 则两个冲突，配置文件生效。
      如果配置基本类的时候，注解和配置文件都使用的时候，注解和配置文件中 name 不相同的时候， 则两个不冲突，都能够生效。

什么是Bean个管理

bean管理指的是如下的两个操作

1.创建对象

2.注入属性

Bean管理操作的两种方式

1.基于xml配置文件的方式实现

2.基于注解方式实现

基于xml配置文件的方式实现Bean管理和注入属性

        1.基于xml方式创建对象

①：这个就是我们上边配置过

②：创建对象的时候，默认是执行无参构造方法完成对象

一篇解决Spring框架所有知识（陆续更新完全）

 1.4.2 基于xml方式注入属性

  •  依赖注入的概述

        IOC和DI的概念

        IOC：Inverse of Control，控制反转，将对象的创建权反转给Spring！！

        DI：Dependency Injection，依赖注入，就是注入属性

  • 属性的set方法注入值

编写属性，提供该属性对应的set方法，编写配置文件完成属性值的注入

public class User {
    // 编写成员属性，一定需要提供该属性的set方法
    //IOC容器底层就通过属性的set方法方式注入值
    private int age;
    private String name;
    private Demo demo;

    public void setAge(int age) {
        this.age = age;
    }

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

    public void setDemo(Demo demo) {
        this.demo = demo;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", demo=" + demo +
                '}';
    }
}

<!‐‐DI：依赖注入‐‐>
<bean id="user" class="com.qcby.service.User" >
    <!--使用property完成属性注入
        name:类里面属性名称
        value:向属性注入值
        ref：对象映射-->
    <property name="age" value="18"></property>
    <property name="name" value="张三"></property>
    <property name="demo" ref="demo"></property>
</bean>

<bean id="demo" class="com.qcby.service.Demo" />
@Test
public void run1(){
    //创建spring工厂，加载配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    //获取bean对象
    User user = ac.getBean("user", User.class);

    System.out.println(user.toString());

}
  • 属性构造方法方式注入值

对于类成员变量，构造函数注入。

public class Car {
    // 名称
    private String cname;
    // 金额
    private Double money;

    public Car(String cname,Double money){
        this.cname = cname;
        this.money = money;
    }

    @Override
    public String toString() {
        return "Car{" +
                "cname='" + cname + '\'' +
                ", money=" + money +
                '}';
    }
}
<bean id="car" class="com.qcby.service.Car">
    <constructor-arg name="cname" value="奔驰"></constructor-arg>
    <constructor-arg name="money" value="35"></constructor-arg>
</bean>
@Test
public void run(){
    //创建spring工厂，加载配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    //获取bean对象
    Car car = ac.getBean("car", Car.class);
    System.out.println(car.toString());
}
  • 数组，集合(List,Set,Map)等的注入
public class CollectionBean {

    private String [] strs;
    private List<String> list;
    private Map<String,String> map;

    public void setStrs(String[] strs) {
        this.strs = strs;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "CollectionBean{" +
                "strs=" + Arrays.toString(strs) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }
}

<!‐‐给集合属性注入值‐‐>
<bean name="collectionBean" class="com.qcby.service.CollectionBean">
    <property name="strs">
        <array>
            <value>美美</value>
            <value>小凤</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>熊大</value>
            <value>熊二</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="aaa" value="老王"/>
            <entry key="bbb" value="小王"/>
        </map>
    </property>
</bean>
@Test
public void getValue(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    Demo demo = (Demo) applicationContext.getBean("demo");
    System.out.println(demo.toString());
}

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之家整理，本文链接：https://www.bmabk.com/index.php/post/115384.html

赞 (0)
Java光头强的头像Java光头强
0 0

相关推荐

发表回复

登录后才能评论
极客之家——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！