栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring框架(一)————IOC(控制反转)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring框架(一)————IOC(控制反转)

Spring框架 1. Spring框架的概述
  • Spring是一个开放源代码的设计层面框架,它解决的是业务逻辑层和其他各层的松耦合问题,因此它将面向接口的编程思想贯穿整个系统应用。
  • 它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 JavaEE 应用程序开发提供集成的框架。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。
  • Spring的核心是控制反转(IOC)和面向切面(AOP)。

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

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

2. Spring框架的优点
  • 方便解耦,简化开发,Spring就是一个大工厂,可以将所有对象创建和依赖关系维护,交给Spring管理,这也是IOC的作用。
  • AOP编程的支持,Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能。
  • 声明式事务的支持,只需要通过配置就可以完成对事务的管理,而无需手动编程。
  • 方便程序的测试,Spring对Junit4支持,可以通过注解方便的测试Spring程序。
  • 方便集成各种优秀框架,Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts2、Hibernate、MyBatis等)的直接支持。
  • 降低JavaEE API的使用难度,Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail等),都提供了封装,使这些API应用难度大大降低。
3.Spring中的Hello World
  • 创建maven工程,导入坐标依赖

  • 
        
            org.springframework
            spring-context
            5.0.2.RELEASE
        
        
            commons-logging
            commons-logging
            1.2
        
        
            log4j
            log4j
            1.2.12
        
        
            junit
            junit
            4.12
            test
        
    
    
  • 编写demo,编写具体的实现方法

  • package com.qcby;
    public class Demo {
        public void hello() {
            System.out.println("hello world");
        }
    }
    
  • 编写Spring核心的配置文件,在resources目录下创建applicationContext.xml的配置文件,名称是可以任意的,但是一般都会使用默认名称。

  • 
    
      	 
        
        
        
    
  • 编写测试方法。

  • package com.qcby;
    
    import com.config.SpringConfig;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class DemoTest {
        //传统写法
        @Test
        public void run(){
            Demo userService = new Demo();
            userService.hello();
        }
        //spring写法
        @Test
        public void run_spring(){
            //创建spring工厂,加载配置文件
            ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
            //获取bean对象
            //这里的getBean后的demo是配置文件中bean的Id,getBean是通过反射来创建对象的
            Demo demo = (Demo) ac.getBean("demo");
            //调用方法
            demo.hello();
        }
    }
    
    

    注意:

    传统方法和Spring创建对象的结果一致

    getBean()是通过反射来创建对象

4.Spring IOC容器

我们从上面的Hello World中可以发现,我们把创建对象的权利交给了Spring来完成,这就是IOC

1. 什么是IOC
  • IOC – Inverse of Control,控制反转,将对象的创建权力反转给Spring框架!

  • 在java当中一个类想要使用另一个类的方法,就必须在这个类当中创建这个类的对象。

    试想:如果有A,B,C三个类,在A类中创建B类对象,B类中创建了C类的对象,如果其中B类出现问题,那么会导致其他类出现问题,这就是耦合度高带来的问题

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

    Spring 将创建对象的权利给了IOC,在IOC当中创建了ABC三个对象,那么我们我们其他的类只需要调用集合, 大大的解决了程序耦合性的问题。

2. IOC容器的底层原理
  • IOC的实现,依赖于以下3门技术

① dom4j解析xml文档;

② 工厂模式;

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

首先我们需要了解什么是工厂模式?

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

通过一个工厂类,工厂类中通过方法来返回不同类的对象,A类调用工厂类生成B的对象,来实现A类中调用B类的方法

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

第一步:xml配置文件,配置创建对象


              

第二步:创建工厂类

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();
   }
}

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

3.IOC(接口)
  • 1.IOC思想是基于IOC容器完成的,IOC的底层就是对象工厂

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

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

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

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

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

5.Spring框架的Bean管理

(1)什么是Bean个管理

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

  • 1.创建对象
  • 2.注入属性

(2)Bean管理操作的两种方式

  • 1.基于xml配置文件的方式实现
  • 2.基于注解方式实现
一、基于xml配置文件的方式实现Bean管理和注入属性 1.基于xml方式创建对象

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



2.基于xml方式注入属性
  • 依赖注入的概述

IOC和DI的概念

IOC:Inverse of Control,控制反转,将对象的创建权反转给Spring!!

DI:Dependency Injection,依赖注入,就是注入属性

属性的set方法注入值

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

User类

public class User {
    private Car car;
    public User() {
    }
    public User(String name, String age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + ''' +
                ", age='" + age + ''' +
                ", car=" + car +
                '}';
    }
    public void eat(){
        System.out.println("我很能吃");
    }

}

Car类

package com.qcby;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("car")
public class Car {
    @Override
    public String toString() {
        return "Car{" +
                "carName='" + carName + ''' +
                '}';
    }

    @Value("奔驰")
    private String carName;
    public void drive(){
        System.out.println("汽车可以驾驶");
    }
}

在application注解配置依赖注入


    
    
    
    
    
    
    
    

测试类

//传统方式赋值
@Test
public void user_set(){
    User user =new User();
    user.setAge("12");
    user.setName("王五");
    Car car =new Car();
    user.setCar(car);
    System.out.println(user.toString());
}
@Test
public void user_spring(){
    //创建spring工厂,加载配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
    //获取bean对象
    //User user = (User) ac.getBean("user");
    User user = ac.getBean("user", User.class);
    //调用方法
    user.eat();
    //对象赋值(注入属性),在配置文件中声明
    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 +
                '}';
    }
}

在application注解配置依赖注入


    
    
    
    

测试类

@Test//传统构造器来注入属性
public void user_constructor(){
    Car car =new Car();
    User user =new User("12","王五",car);
    System.out.println(user.toString());
}

@Test
public void user_spring(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
    //获取bean对象
    User user = ac.getBean("user", User.class);
    //调用方法
    user.eat();
    System.out.println(user.toString());
}
数组,集合(List,Set,Map)等的注入
public class CollectionBean {
    private String [] strs;
    private List list;
    private Map map;

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

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

    public void setMap(Map map) {
        this.map = map;
    }

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

在application注解配置依赖注入



    
        
            美美
            小凤
        
    
    
        
            熊大
            熊二
        
    
    
        
            
            
        
    

测试类

@Test
public void getValue(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    Demo demo = (Demo) applicationContext.getBean("demo");
    System.out.println(demo.toString());
}
二、基于注解的方式实现Bean管理和注入属性 1.什么是注解
  • ①:注解是代码特殊标记,格式:@注解名称(属性名称=属性值,属性名称=属性值…)
  • ②:使用注解,注解作用在类上面,方法上面,属性上边
  • ③:使用注解的目的:简化XML配置
2.Spring针对Bean管理中创建对象提供的注解
  • @Component 普通的类
  • @Controller 表现层
  • @Service 业务层
  • @Repository 持久层

上边四个功能一样,都可以用来创建bean实例,使用场景不一致

用注解的方式创建对象

默认使用类的无参构造方法

  • ①:在需要管理的类上添加注解
package com.qcby;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

//@Component//注解普通类
//@Controller//表示层
//@Service//业务层
//@Repository//持久层
//这四种方式都可以实例bean对象
@Component(value = "user")
//@Controller(value = "user")
//@Repository(value = "user")
//@Service(value = "user")
public class User {
    public void eat(){
        System.out.println("我很能吃");
    }

}
  • ②:编写配置文件,重点是开启注解扫描


   
    
    

  • ③:编写测试方法
 @Test
    public void user_spring(){
        //创建spring工厂,加载配置文件
        ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
        //获取bean对象
        User user = (User) ac.getBean("user");
        //调用方法
        user.eat();
        //对象赋值(注入属性),在配置文件中声明

    }
用注解的方实现属性注入
  • @Value 用于注入普通类型(String,int,double,以及对应的包装类等类型)
  • @Autowired 默认按类型进行自动装配(引用类型),不需要写值(名称)
  • @Qualifier 不能单独使用必须和@Autowired一起使用,强制使用名称注入
  • @Resource Java提供的注解,也被支持。使用name属性,按名称注入,只能在引用类型中使用
  • 前三个都是Spring提供的注解,最后一个是Java提供的注解

具体代码如下:

User类

package com.qcby;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

//@Component//注解普通类
//@Controller//表示层
//@Service//业务层
//@Repository//持久层
//这四种方式都可以实例bean对象
@Component(value = "user")
//@Controller(value = "user")
//@Repository(value = "user")
//@Service(value = "user")
public class User {
    @Value("李四")
    private String name;
    @Value("18")
    private String age;
    @Qualifier("car")
    @Autowired//注入引用类型,注意对应的Car类要用注解来实例化,不需要写值,会自动根据Car类型来实例化
    //java提供的注解
    //@Resource(name = "car")
    private Car car;

    public User() {
    }

    public User(String name, String age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

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

    public void eat(){
        System.out.println("我很能吃");
    }

}

Car类

package com.qcby;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component("car")
public class Car {
    @Override
    public String toString() {
        return "Car{" +
                "carName='" + carName + ''' +
                '}';
    }

    @Value("奔驰")
    private String carName;
    public void drive(){
        System.out.println("汽车可以驾驶");
    }
}

测试方法

@Test
public void user_spring(){
    //创建spring工厂,加载配置文件
    ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
    //获取bean对象
    User user = (User) ac.getBean("user");
    //调用方法
    user.eat();
    //对象赋值(注入属性),在配置文件中声明
    System.out.println(user.toString());
}

IOC纯注解的方式

纯注解的方式是微服务架构开发的主要方式,所以也是非常的重要。纯注解的目的是替换掉所有的配置文件。但是需要编写配置类。

常用的注解总结

  • @Configuration 声明是配置类
  • @ComponentScan 扫描具体包结构的

实体类不变还是上文的User和Car

编写配置类,替换掉applicationContext.xml配置文件

package com.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration//表示这是配置类
// 扫描指定的包结构
@ComponentScan(value = "com.qcby")
public class SpringConfig {

}

测试方法的编写

@Test
//纯注解形式完成
public void user_spring2(){
    //创建spring工厂,加载配置文件
    ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
    //获取bean对象
    User user = (User) ac.getBean("user");
    //调用方法
    user.eat();
    //对象赋值(注入属性),在配置文件中声明
    System.out.println(user.toString());

}

这里的加载的就不是xml文件,而是配置类了

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/955765.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号