000_spring(ioc、di)

最新推荐文章于 2024-07-18 11:27:31 发布
最新推荐文章于 2024-07-18 11:27:31 发布
阅读量100 收藏
点赞数
文章标签： 测试 设计模式 netty
原文链接：http://www.cnblogs.com/zrmj/p/11452547.html
版权

spring

spring

spring是一个轻量级的控制反转（IOC、DI）和面向切面编程（AOP)的对象容器框架

spring官网：http://spring.io/

IOC:inversion of control

AOP:aspect oriented programming

作用：

  • 方便解耦，简化开发

  • aop编程的支持

  • 声明事物的支持

  • 方便程序的测试

  • 方便集成各种框架

spring jar包

 

 

spring-core

框架的基础功能，包括IOC和AOP功能

spring-aspects

提供了与AspectJ的集成，AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。

spring-beans

所有应用都要用到，包含访问配置文件、创建和管理 bean 以及进行 Inversion of Control(控制反转) / Dependency Injection（依赖注入）操作相关的所有类。外部依赖 spring-core

spring-context

 

spring-aop、spring-instrument

面向切面编程、植入代理

spring-expression

模块提供了强大的表达式语言去支持查询和操作运行时对象图。这是对JSP 2.1规范中规定的统一表达式语言的扩展。该语言支持设置和获取属性值，属性分配，方法调用，访问数组，集合和索引器的内容，逻辑和算术运算，变量命名以及从Spring的IoC容器中以名称检索对象。 它还支持列表投影和选择以及常见的列表聚合。

spring-messaging

消息传递

spring-jdbc、spring-jms、spring-orm

数据访问支持

spring-jcl

Jakarta Commons Logging采用了设计模式中的“适配器模式”，它对外提供统一的接口，然后在适配类中将对日志的操作委托给具体的日志框架。

spring-tx

事务

spring-webmvc、spring-web

Webmvc框架支持

spring-webflux

Servlet3.1 + Netty 方式的WebMvc

spring-websocket

对ws支持

 实例：

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:mvc="http://www.springframework.org/schema/mvc"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">


<bean id="Person" class="com.zrm.Person">
<constructor-arg name="name" value="zrm"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="food" ref="food"></constructor-arg>
</bean>
<bean id="food" class="com.zrm.Food">

</bean>
</beans>

package com.zrm;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class GetBean {
public static void main(String[] args) {
// 通过spring来获取一个类的控制权
// ClassPathXmlApplicationContext ctx = new
// ClassPathXmlApplicationContext("applicationContext.xml");

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) ctx.getBean("Person");
// person.setAge(18);
// person.setName("zrm");
// System.out.println(person.getName());
// System.out.println(person.getAge());
System.out.println(ToStringBuilder.reflectionToString(person,ToStringStyle.MULTI_LINE_STYLE));//ToStringBuilder工具类

}
}

maven中央仓库：

https://mvnrepository.com/

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zrm.springmaven</groupId>
    <artifactId>springm</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springm</name>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
 

    </dependencies>
</project>

spring注入方式：

  • 构造器注入 constructor-arg：通过构造器注入，在bean中必须要有想对应的构造器

　　　　　<constructor-arg name="name" value="zrm"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="food" ref="food"></constructor-arg>


　　　　　　构造方法如下：

　　　　　　public Person(String name, Integer age, Food food) {
　　　　　　super();
　　　　　　this.name = name;
　　　　　　this.age = age;
　　　　　　this.food = food;
　　　　　　}

  • 属性注入：不需要构造器，实际上是通过调用set方法来实现

package com.zrm;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Person {

//不同类型的成员变量
private String name;
private Integer age;
private Food food;
private List<Integer> list;
private Set<Integer> set;
private Map<Integer, String> map;
private Properties properties;
private String[] arr;

public Food getFood() {
return food;
}

public void setFood(Food food) {
this.food = food;
}

public List<Integer> getList() {
return list;
}

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

public Set<Integer> getSet() {
return set;
}

public void setSet(Set<Integer> set) {
this.set = set;
}

public Map<Integer, String> getMap() {
return map;
}

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

public Properties getProperties() {
return properties;
}

public void setProperties(Properties properties) {
this.properties = properties;
}

public String[] getArr() {
return arr;
}

public void setArr(String[] arr) {
this.arr = arr;
}

public Person() {
super();
}

public String getName() {
return name;
}

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

public Integer getAge() {
return age;
}

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

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:mvc="http://www.springframework.org/schema/mvc"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">


<bean id="Person" class="com.zrm.Person">
<property name="name" value="zrm"></property>
<property name="age">
<value>18</value>
</property>
<property name="food" ref="food"></property>

<property name="list">

//list集合
<list>
<value>1</value>
<value>2</value>
<value>3</value>
<value>2</value>
<value>1</value>
</list>
</property>

 

//set集合

<property name="set">
<set>
<value>1</value>
<value>2</value>
<value>3</value>
<value>2</value>
<value>1</value>
</set>
</property>

<property name="map">
<map>
<entry key="1" value="first"></entry>
<entry key="2" value="food"></entry>
</map>
</property>

//Properties多属性

<property name="properties">
<props>
<prop key="1">first</prop>
<prop key="2">first2</prop>
<prop key="3">first3</prop>
<prop key="4">first4</prop>
<prop key="5">first5</prop>
<prop key="6">first6</prop>
</props>
</property>

//数组

<property name="arr">
<array>
<value>1</value>
<value>2</value>
<value>3</value>
<value>4</value>
<value>5</value>
<value>6</value>
</array>
</property>


</bean>
<bean id="food" class="com.zrm.Food">
<property name="name" value="orange"></property>
</bean>
</beans>

 

  • 使用p-namespace

    属性注入

             添加一个namespace

    使用 p

    <bean id="person" class="com.msb.Person"  p:age="21" p:name = "zhangsan">

    <bean id="person" class="com.msb.Person"  p:age="21" p:name = "zhangsan" p:food-ref="food">

    使用c- namespace

    构造器注入

    <bean id="foo" class="x.y.Foo" c:bar-ref="bar" c:baz-ref="baz" c:email= "foo@bar.com"/>

 对其他bean的引用：

<property name="food" ref="food"></property>

<bean id="food" class="com.msb.Food"></bean>

  • depends-on 提前初始化

可以使某个bean在创建前，先创建别的bean

  • lazy-init

在容器启动后，bean被使用到的时候才加载。可以使用的lazy-init属性

bean id="person" class="com.msb.Person" lazy-init="false"

  • 作用域

    spring为bean提供了6种作用域，其中4种只有在web-aware的ApplicationContext种才有用。用户也可以创建自定义的作用域。

    singleton 、prototype 、websocket、request、session、application

    singleton scope 单例作用域

    每一个类，在一个容器内只能产生一个实例

    prototype scope 原型作用域

    该bean每次被注入，或者使用getBean()方法获取时，都返回一个新的实例。

    Request scope

    该作用域的bean，在每个HTTP request都会新建一个实例，当一个request结束后，该实例也会被丢弃。

    Session scope

    某一个用户在一段时间内，会使用同一个session，session有超时时间，过了超时时间则session失效。不同用户使用不同的session。

    Application scope

    该作用域的bean，每一个application会创建一个

  • 通过属性注入

    l   循环依赖的bean都是singleton 成功

    l   循环依赖的bean都是prototype 失败

    l   同时有singleton和prototype 当先获取的那个bean是singleton时，就会成功，否则失败

    l  

    当Spring容器在创建A时，会发现其引用了B，从而会先去创建B。同样的，创建B时，会先去创建C，而创建C时，又先去创建A。最后A、B、C之间互相等待，谁都没法创建成功

  • annotation注解注入

    使用注解需要导入AOP包

    在配置文件中添加Context约束

    <beans xmlns="http://www.springframework.org/schema/beans"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xmlns:p="http://www.springframework.org/schema/p"

         xmlns:context="http://www.springframework.org/schema/context"

         xsi:schemaLocation="

         http://www.springframework.org/schema/beans           http://www.springframework.org/schema/beans/spring-beans.xsd

         http://www.springframework.org/schema/context                    http://www.springframework.org/schema/context/spring-context.xsd

         "

         >

     

    <context:component-scan>

    <context:component-scan base-package="com.msb"></context:component-scan>

    component-scan可以自动扫描包内容，并注册Bean到Spring容器

    @Component

    在需要注册到容器的类上添加@Component标签，标识这个类由Spring容器接管

    约定大于配置

    在一个类上添加@Component默认会使用首字母小写的类名作为ID注册到Spring容器。

    如果需要手动指定Bean Id可以使用@Component("p")

    同属@Component的额外三个注解

    @Controller @Service @Repository

    这三个注意在MVC开发中会经常用到，除了注解名字和Component不一样之外，其余功能都一样。

    Spring额外提供这三个注解的目的主要是为了区分MVC中每个类的区别。

    @Scope

    使用注解注册Bean 默认的作用域还是singleton，可以使用@Scope("prototype")改变对象作用域

    @Value

     

    在使用注解给对象注入值的时候，不再需要Get/Set方法

    基础类型

    使用@Value注解

         @Value("小明")

         private String name;

     

    对象引用

         @Autowired

         private Pet MyPet;

    使用@Autowired注解

    默认是ByType的，如果需要ByName需要配合@Qualifier注解

         @Autowired()

         @Qualifier("p2")

         private Pet MyPet;

     

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:p="http://www.springframework.org/schema/p"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">


    <bean id="person" class="com.zrm.Person" name="person3" lazy-init="false" scope="singleton">
        <!--空值注入
        <property name="name"><value></value></property>-->
        <!--空值注入
        <property name="name"><null></null></property>-->
        <!--自动注入-->
        <!--<property name="age">
                    <value>18</value>
                </property>-->
    </bean>
    <!--别名-->
    <alias name="person" alias="person1"></alias>
    <alias name="person" alias="person2"></alias>
</beans>

     

转载于:https://www.cnblogs.com/zrmj/p/11452547.html

dcyu76046
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
请简述什么是spring的ioc和di_Spring中的IoC与DI的理解
weixin_30099989的博客
12-28 1736
1.IoC是什么？IoC(Inversion of Control)控制反转，IoC是一种新的Java编程模式，目前很多轻量级容器都在广泛使用的模式。2.IoC解决了什么问题？在IoC出现以前，组件之间的协调关系是由程序内部代码来控制的，或者说，以前我们使用New关键字来实现两组间之间的依赖关系的。这种方式就造成了组件之间的互相耦合。IoC(控制反转)就是来解决这个问题的，它将实现组件间的关系从程...
实验四_SpringIoC.rar
04-13
Spring框架是Java开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IoC）功能而闻名。在这个实验中，我们将深入理解并实践Spring IoC的核心...
IOC 和DC
热门推荐
chenweihua556的专栏
09-17 1万+
来自http://www.cnblogs.com/xdp-gacl/p/4249939.html 一、分享Iteye的开涛对Ioc的精彩讲解 　　首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解，写得非常通俗易懂，以下内容全部来自原文，原文地址：http://jinnianshilongnian.iteye.com/blog/1413846
Spring 学习之路（二）： Spring IOC(DC) 的初步了解
03-15 452
Spring最重要的功能之一： IOC（DI） IOC(Inversion of Control)：其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式 DI(Dependency I...
Spring.Net 框架(IOC\DI)和配置案例
qinzheng_chen的博客
12-08 263
IOC和DC是一起为了解决对象创建的solution IOC：中文控制反转 DI依赖注入 DI就是给对象添加初始值 spring.Net 配置 https://www.cnblogs.com/yougmi/p/4545514.html 配置<configSections> 和<spring>两个节点 嵌入操作： resource...
spring中IoC和DI浅析
ldcaws的专栏
08-16 980
IoC和DI都是spring框架中的重要概念，通常也是成对出现的，下面对IoC和DI及其关系进行简单分析。
spring IOC和DI 理解
zhang2383906154的博客
11-15 2732
IOC(控制反转)和DI（依赖注入）是spring中的重要组成部分，下面是个人的一些理解，不代表官方。 1、IOC是什么？ IOC:全名是Inversion of Controller 中文解释是控制反转，不是什么技术，是一种设计思想。在java开发中IOC意味着你设计好的对象交给容器控制，而不是传统的在你对象内部直接控制。如何理解好IOC那？理解IOC的关键是要明确：“谁控制谁”、“控制什么”、为何是反转（有反转就应该有正转）哪些方面反转了，我们来分析一下： 1）谁控制谁，控制什么：传统的java
Spring——IoC和DI
浪漫不死的博客
03-02 3125
目录一、初识Spring为什么要使用Spring什么是SpringSpring框架的核心由哪些模块组成二、Core Container（核心容器）IoC（控制反转）什么是 IoCIoC 的作用IoC 的优点IoC 的缺点DI（依赖注入）什么是DI依赖注入的基本原则依赖注入的优势不同类型的依赖注入实现方式构造器依赖注入和 Setter方法注入的区别顶级接口BeanFactory 和 ApplicationContext 的区别BeanFactory和ApplicationContext的关系详解Applica
请简述什么是spring的ioc和di_Spring中IOC与DI的的区别
weixin_39932947的博客
12-19 487
依赖注入的前提:有IOC的环境,也就是将必须对象的创建权交给了Spring.DI 介绍Dependency Injection 依赖注入.需要有IOC 的环境,Spring 创建这个类的过程中,Spring 将类的依赖的属性设置进去.IOC与DI的的区别:IOC: 控制反转,将类的对象的创建交给Spring类管理创建.DI: 依赖注入,将类里面的属性在创建类的过程中给属性赋值.DI和IOC...
Spring IOC&DI
zhuge_long的专栏
05-31 1035
Resource注解与@Autowired注解的作用是一样的，都是用来为bean对象注入值的，唯一的区别是@Resource注解要根据实例化的bean名称为bean对象注入值。@Resource(name = “userDaoImpl2”)//name属性设置注入对象的属性名，如果属性名和name注入的名称一致的，name可以不赋值。Spring5.0开始，倡导以注解方式完成对象的管理，如果对象无法使用注解，就将对象交给spring的配置统一管理，而不再推荐使用xml配置的方式！
spring IOC及DI的理解
他
03-18 371
IOC及DI是一个意思是从不同角度看的两种说法 ioc控制反转（从使用的角度） 原来在业务中需要自己去new对象，现在直接交给spring容器来管理（由spring容器的 bean工厂来new对象）不需要关心何时创建他，直接用这个对象即可，因为会在你用时spring容器会自动创建对象 DI依赖注入（被使用的角度） 原来的业务需要用到这个对象，需要进行new,现在通过告诉spring容器我现在要用这个对象，spring容器就会为你创建好对象，这个关系体现出了依赖，有需求（依赖）就会给你创建（注入） ...
Spring IOC和Spring AOP_spring aop_springIOC
09-24
Spring框架是Java开发中最常用的轻量级框架之一，它的核心特性包括依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）。这两个概念是Spring框架的基石，极大地简化了...
Spring_IOC_.rar_spring ioc
09-23
在Spring框架中，IOC主要体现在两个方面：依赖注入（Dependency Injection，简称DI）和Bean工厂。依赖注入是IOC的核心，它允许我们不通过硬编码的方式来指定对象之间的依赖关系，而是通过配置文件或注解来声明这些...
SpringIOC DI循环依赖实例详解
08-24
SpringIOC DI 循环依赖实例详解 SpringIOC 是一个基于依赖注入（Dependency Injection，简称 DI）的容器，用于管理 Bean 的生命周期。 DI 循环依赖是指在 Bean 初始化过程中出现的循环依赖问题，即一个 Bean 依赖于...
spring_Ioc
08-07
Spring IOC，全称为Inversion of Control，即“控制反转”，是Spring框架的核心特性，它极大地简化了Java应用的开发工作。在传统的Java程序中，开发者需要手动创建对象并管理它们之间的依赖关系，而在Spring IOC的...
HDU1000，HDU1001，HDU1002，HDU1003，HDU1004
u014114223的博客
07-17 1336
执行加法操作，根据两个数的长度选择较长的一个进行循环。在每次迭代中，将对应的位相加，同时加上来自更高位的进位（如果有的话），并将结果存储在。首先输出测试用例的编号，然后是原始的两个大整数（按照原始顺序输出），接着是等于号和加法的结果。使用循环将字符串中的数字转换为整数，并反向存储在。在不同的测试用例之间，输出一个空行以便区分。的长度减一，这是因为数组是从1开始索引的。等于0的情况，此时循环结束，程序随之结束。：最后，函数返回0，表示程序正常结束。，代表要相加的两个大整数。首先，读取测试用例的数量。
软件测试-测试用例设计方法（附实际项目用例）
最新发布
qq_61167424的博客
07-18 738
本篇文章主要介绍按照测试对象进行分类，设计测试用例的方法有哪些
软件测试——面试八股文（入门篇）
yjt2045263063的博客
07-15 1068
α测试：在受控的环境中进行，由用户在开发者的场所进行，并且在开发者对用户的指导下进行测试，开发者负责记录发现的错误和使用中遇到的问题β测试：在开发者不能控制的环境中的真实应用，由软件的最终用户们在一个或多个客户场所下进行，由用户记录在测试中遇到的一系列问题，并定期报给开发者。结语鉴于篇幅所限，选出经典17个软件测试面试题（入门篇）需要完整面经的朋友可以关注并私信我关键词“资料”免费领取。
外包干了1个月，技术明显退步。。。
HUA6911的博客
07-15 2687
什么都做了，和什么都没做其实是一样的，走出“瞎忙活”的安乐窝，才是避开弯路的最佳路径。希望我的经历能帮助到有需要的朋友，同时也给各位准备了一份资源，盘里头是一整套软件测试必备资料。
spring ioc DI
07-23
在Spring框架中，IOC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）是两个重要的概念。 IOC是一种设计原则，它反转了传统的程序设计中对象的创建和依赖关系的管理方式。传统方式中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值