Spring依赖注入 c命名空间注入 p命名空间注入

最新推荐文章于 2022-10-23 23:06:27 发布
最新推荐文章于 2022-10-23 23:06:27 发布
阅读量1.6k 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40791843/article/details/97394055
版权

Spring的简单介绍

  1. Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架，Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式。
    在这里插入图片描述
  2. Spring框架即以 interface21 框架为基础。
  3. Spring框架：
    3.1 轻量级
    3.2 面向切面
    3.3 控制翻转 （IOC）【inversion of Control】：类的实例由容器的ClassPathXmlApplicationContext创建。
    3.4 Spring 包含并管理对象的创建和生命周期，在意义上，它是一个容器。
    3.5 框架：在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等)，将应用逻辑的开发留给了你。
  4. Spring 优点：
    4.1.低侵入式设计，代码污染极低。
    4.2.独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺。
    4.3.Spring的DI机制降低了业务对象替换的复杂性，提高了组件之间的解耦。
    4.4.Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用。
    4.5.Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。
    4.6.Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部。

Spring的简单使用

  1. 首先在maven中找到Spring的依赖：https://mvnrepository.com/artifact/org.springframework/spring-webmvc
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.9.RELEASE</version>
        </dependency>
  1. 实体类
package com.baidu.pojo;

public class Hello {
    private int age;
    private String sex;
    private String name;

    public Hello(String name) {
        System.out.println("有参构造只有name的");
        this.name = name;
    }

    public Hello(int age, String sex, String name) {
        System.out.println("有参构造全部内容");
        this.age = age;
        this.sex = sex;
        this.name = name;
    }

    public Hello(){
        System.out.println("无参构造");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("通过set方法设置name");
    }

    @Override
    public String toString() {
        return "Hello{" +
                "age=" + age +
                ", sex='" + sex + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}
  1. 创建对应的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"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--通过无参构造和set方法创建对象-->
    <bean id="hello1" class="com.baidu.pojo.Hello">
        <property name="name" value="Spring"></property>
    </bean>
	<!--通过有参构造创建对象，最后通过set重新设置name属性-->
    <bean id="hello2" class="com.baidu.pojo.Hello">
        <constructor-arg index="0" value="18"/>
        <constructor-arg index="2" value="girl"/>
        <constructor-arg index="1" value="郝一凡1"/>
        <property name="name" value="郝一凡6"/>
    </bean>
	<!--通过有参构造创建对象-->
    <bean id="hello3" class="com.baidu.pojo.Hello">
        <constructor-arg value="18"/>
        <constructor-arg value="girl2"/>
        <constructor-arg value="郝一凡3"/>
    </bean>
    <!--通过有参构造创建对象-->
    <bean id="hello4" class="com.baidu.pojo.Hello">
        <constructor-arg name="age" value="19"/>
        <constructor-arg name="name" value="郝一凡4"/>
        <constructor-arg name="sex" value="gril4"/>
    </bean>
	<!--通过参数的数据类型创建对象-->
    <bean id="hello5" class="com.baidu.pojo.Hello">
        <constructor-arg type="java.lang.String" value="郝一凡5"/>
    </bean>
    <!--给创建的对象起别名-->
    <alias name="hello5" alias="hellohello"/>
</beans>
  1. 测试类
package com.baidu.pojo;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Hello hello1 = (Hello) context.getBean("hello1");
        System.out.println(hello1.toString());
    }

    @Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Hello hello1 = (Hello) context.getBean("hello2");
        System.out.println(hello1.toString());
    }

    @Test
    public void test3(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Hello hello1 = (Hello) context.getBean("hello3");
        System.out.println(hello1.toString());
    }

    @Test
    public void test4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Hello hello1 = (Hello) context.getBean("hello4");
        System.out.println(hello1.toString());
    }

    @Test
    public void test5(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Hello hello1 = (Hello) context.getBean("hellohello");
        System.out.println(hello1.toString());
    }
}

我这里测试的是test5
在这里插入图片描述
6. bean.xml 中的import标签

<!--
    classpath*:会在所有文件中去找，效率低，不建议使用
    classpath：在此项目中找寻，效率高，建议使用
    file：需要找到文件的绝对路径，不推荐使用
    http：需要找到文件的网络路径，不推荐使用
    -->
    <import resource="classpath*:"/>
    <import resource="classpath:"/>
    <import resource="file:"/>
    <import resource="http:"/>

依赖注入DI

  1. 创建实体类
package com.baidu.pojo;

import java.util.*;

public class User {
    private String name;
    private int age;
    private Address address;
    private String[] hobbys;
    private Set<String> books;
    private List<String> names;
    private Map<String,String> users;
    private Properties properties;
    private User girlFriend;

    public User() {
    }

    public User(String name, int age, Address address, String[] hobbys, Set<String> books, List<String> names, Map<String, String> users, Properties properties, User girlFriend) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.hobbys = hobbys;
        this.books = books;
        this.names = names;
        this.users = users;
        this.properties = properties;
        this.girlFriend = girlFriend;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                ", hobbys=" + Arrays.toString(hobbys) +
                ", books=" + books +
                ", names=" + names +
                ", users=" + users +
                ", properties=" + properties +
                ", girlFriend=" + girlFriend +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getHobbys() {
        return hobbys;
    }

    public void setHobbys(String[] hobbys) {
        this.hobbys = hobbys;
    }

    public Set<String> getBooks() {
        return books;
    }

    public void setBooks(Set<String> books) {
        this.books = books;
    }

    public List<String> getNames() {
        return names;
    }

    public void setNames(List<String> names) {
        this.names = names;
    }

    public Map<String, String> getUsers() {
        return users;
    }

    public void setUsers(Map<String, String> users) {
        this.users = users;
    }

    public Properties getProperties() {
        return properties;
    }

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

    public User getGirlFriend() {
        return girlFriend;
    }

    public void setGirlFriend(User girlFriend) {
        this.girlFriend = girlFriend;
    }
}


package com.baidu.pojo;

public class Address {
    private String name;

    public Address() {
    }

    public Address(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Address{" +
                "name='" + name + '\'' +
                '}';
    }
}
  1. 配置对应的bean.xml文件
<bean id="user" class="com.baidu.pojo.User">
        <!--普通注入-->
        <property name="name" value="郝一凡"/>
        <!--引入注入-->
        <property name="address" ref="address"/>

        <property name="age" value="18"/>
        <!--set注入-->
        <property name="books">
            <set>
                <value>西游记</value>
                <value>三国演义</value>
                <value>红楼梦</value>
                <value>水浒传</value>
            </set>
        </property>
        <!--空值注入-->
        <property name="girlFriend">
            <null/>
        </property>
        <!--数组注入-->
        <property name="hobbys">
            <array>
                <value>电影</value>
                <value>音乐</value>
                <value>游戏</value>
            </array>
        </property>
        <!--list注入-->
        <property name="names">
            <list>
                <value>王者荣耀</value>
                <value>刺激战场</value>
                <value>绝地求生</value>
            </list>
        </property>
        <!--map注入-->
        <property name="users">
            <map>
                <entry key="name" value="郝一龙"/>
                <entry key="age" value="14"/>
                <entry key="sex" value="boy"/>
            </map>
        </property>
        <!--properties注入-->
        <property name="properties">
            <props>
                <prop key="时间">2019-07-26</prop>
            </props>
        </property>
    </bean>

c命名空间注入和p命名空间注入

这个的使用要在bean.xml文件的头目录里面加上两行语句
	   xmlns:p="http://www.springframework.org/schema/p" 
       xmlns:c="http://www.springframework.org/schema/c"

<bean id="address1" class="com.baidu.pojo.Address" p:name="陕西省"/>
<bean id="address2" class="com.baidu.pojo.Address" c:name="宝鸡市"/>
小白葫芦
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring框架如何使用P命名空间进行注入
08-25
其中，P命名空间是 Spring 框架中的一种依赖注入机制，使用 P 命名空间可以简化对象之间的依赖关系配置。 在 Spring 框架中，P 命名空间是基于 setter 方法的依赖注入机制。开发者可以通过在 Bean 的 setter 方法中...
spring依赖注入知识点分享
08-25
Spring 依赖注入知识点分享 在本篇文章中，我们将详细介绍 Spring 依赖注入的知识点，并提供相关的代码内容。 什么是 IoC IoC（Inversion of Control），即控制反转，是一种软件设计模式。它将对象之间的依赖关系...
spring——Spring Bean属性注入——短命名空间注入——c 命名空间注入（转载）
小白龙白龙马的博客
04-17 274
c 命名空间注入 c 命名空间是构造函数注入的一种快捷实现方式。通过它，我们能够以 <bean> 属性的形式实现构造函数方式的属性注入，而不再使用嵌套的 <constructor-arg> 元素，以实现简化 Spring 的 XML 配置的目的。 首先我们需要在配置文件的 <beans> 元素中导入以下 XML 约束。 xmlns:c="http://ww...
spring中的c命名空间和p命名空间是什么？
技术积累，技术分享
03-21 2115
p命名空间 spring中的p命名空间就是为了更加方便的使用set方法注入属性内容 举例说明： User实体类 public class User { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; }
7.依赖注入之为list，map集合类型的属性赋值以及p命名空间
m0_56379670的博客
10-23 242
【代码】7.依赖注入之为list，map集合类型的属性赋值。
Spring p名称空间注入和c名称空间注入
qq_36382679的博客
04-24 266
P代表propertory 属性, 是set注入的简化方式 (提供set方法) C代表Constructor 构造注入的简化方式 (提供构造方法) package com.itheima.di; import java.util.Date; /** * set注入 ,必须要有set方法 * */ public class Person { private int id; ...
Spring c命名空间和p命名空间注入
Harris-H的博客
01-18 413
Spring c命名空间和p命名空间注入 c命名空间和p命名空间不能直接使用，需要在bean的xml文件中导入xml约束。 实体类(User) package com.harris.pojo; public class User { private String name; private int age; public User(String name, int age) { this.name = name; this.age = age;
谈谈Spring 注入properties文件总结
08-31
Spring框架在处理应用程序的配置和依赖注入方面非常强大，它允许开发者从外部的properties文件中加载配置信息，以便于管理数据库连接、系统属性等。在本文中，我们将深入探讨Spring如何注入properties文件，并总结几...
Spring的自动扫描注入.docx
11-29
在 Spring 框架中，依赖注入是指将一个对象提供给另一个对象，以满足其依赖关系。例如，将 DAO 实现类注入到 Service 实现类中，将 Service 的接口（注意不要是 Service 的实现类）注入到 Action 中。在注入时，不要...
CH02-IOC依赖注入.pptx
12-28
理解什么是IoC和DI。 理解构造注入 理解不同数据类型的注入方法 掌握p命名空间注入 Bean自动装配
Spring5.0 -- 通过 Set 方式依赖注入（DI）普通注入、数组、List、Map、Set、Null、Properties；使用p命名空间和c命名空间进行注入
Kc635908933的博客
02-27 372
文章目录一. 通过 Set 方式注入[ 重点 ]1.1 Address 类1.2 Student 类1.3 beans.xml 配置文件1.4 测试类1.5 结果二. 拓展空间注入（p命名空间、c命名空间）2.1 beans.xml 配置文件2.2 测试类2.3 注意点 依赖注入：Set注入！ – 依赖：bean对象的创建依赖于容器！ – 注入：bean对象中的所有属性，由容器来注入！ 一. 通过 Set 方式注入[ 重点 ] 1.1 Address 类 public class Address {
spring配置文件中的p和c命名空间的使用
wqh0830的博客
01-09 1462
1、p命名空间和c命名空间 在通过构造方法或set方法给bean注入关联项时通常是通过constructor-arg元素和property元素来定义的。在有了p(property)命名空间和c(constructor-arg)命名空间时我们可以简单的把它们当做bean的一个属性来进行定义。 1.1、p命名空间 使用p命名空间时需要先声明使用对应的命名空间，即在beans元素上加入xmlns:...
Spring采用p名称空间注入的方式
qq30211478的博客
06-07 1324
从Spring 2.0开始，就支持使用名称空间的可扩展配置格式。这些名称空间都是基于一种XML Schema定义。事实上，我们所看到的所有bean的配置格式都是基于一个 XML Schema文档。特定的名称空间并不需要定义在一个XSD文件中，它只在Spring内核中存在。p名称空间是不需要schema定义的，因此属性（attribute）的名字就是你bean的property的名字。 举例
Spring c命名空间与p命名空间
weixin_45736498的博客
04-26 154
P命名空间 官网： 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" xsi:schemaLocati...
Java 命名空间的由来和引入
热门推荐
SmcWjm的专栏
08-13 2万+
名字可视性（Name visibility） 名字管理对任何程序设计语言来说，都是一个重要问题。如果你在程序的某个模块里使用了 一个名字，而其他人在这个程序的另一个模块里也使用了相同的名字，那么怎样才能区分这 两个名字并防止二者互相冲突呢？这个问题在 C 语言中尤其严重，因为程序往往包含许多 难以管理的名字。C++类( Java 类基于此)将函数包于其内，从而避免了与其它类中的函
Spring命名空间注入
qq_40392686的博客
10-02 565
p命名空间注入 需要有set方法 需要添加约束 xmlns:p=&quot;http://www.springframework.org/schema/p&quot; xml配置文件 &amp;lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&amp;gt; &amp;lt;beans xmlns=&quot;http://w
Spring的c命名空间，实际是构造器注入
林高禄
11-04 1150
构造器注入 c命名空间 官方解释 测试 Sping配置里有一个c命名空间，实际上就是构造器注入 构造器注入 Spring之IOC通过构造方法实例化Bean的方式 c命名空间 要使用c命名空间，就得导入约束 官方解释 测试 xmlns:c="http://www.springframework.org/schema/c" ...
p名称空间的属性注入、集合属性的注入以及Spring分模块配置
Woo_home的博客
04-27 724
一、p名称空间的属性注入（版本：Spring2.5以后的） <beans xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"...
如何接入apollo，实现spring依赖注入的bean动态刷新
最新发布
06-01
接入Apollo实现Spring依赖注入的Bean动态刷新，需要以下步骤： 1. 引入Apollo的依赖 在Maven或Gradle中添加Apollo的依赖： Maven： ```xml <dependency> <groupId>com.ctrip.framework.apollo</groupId> <artifactId>apollo-client</artifactId> <version>${apollo.version}</version> </dependency> ``` Gradle： ``` compile 'com.ctrip.framework.apollo:apollo-client:${apollo.version}' ``` 其中`${apollo.version}`是Apollo的版本号。 2. 实现ApolloConfigChangeListener接口 ```java import com.ctrip.framework.apollo.model.ConfigChangeEvent; import com.ctrip.framework.apollo.spring.annotation.ApolloConfigChangeListener; import org.springframework.stereotype.Component; @Component public class MyApolloConfigChangeListener { @ApolloConfigChangeListener private void onChange(ConfigChangeEvent changeEvent) { // 配置变化时的回调方法 } } ``` 3. 实现BeanPostProcessor接口 ```java import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.stereotype.Component; @Component public class MyBeanPostProcessor implements BeanPostProcessor { private final ConfigurableListableBeanFactory beanFactory; public MyBeanPostProcessor(ConfigurableListableBeanFactory beanFactory) { this.beanFactory = beanFactory; } @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof MyConfigurableBean) { MyConfigurableBean myConfigurableBean = (MyConfigurableBean) bean; String configValue = myConfigurableBean.getConfigValue(); // 从Apollo配置中心获取配置 myConfigurableBean.setConfigValue(configValue); } return bean; } @ApolloConfigChangeListener private void onChange(ConfigChangeEvent changeEvent) { if (changeEvent.isChanged("my.config.key")) { beanFactory.destroySingleton("myConfigurableBean"); // 销毁旧的Bean实例 } } } ``` 在这个例子中，我们实现了一个`MyConfigurableBean`，这个Bean的属性`configValue`是从Apollo配置中心获取的。当Apollo配置中心的配置发生变化时，我们会销毁旧的Bean实例，并重新创建新的Bean实例。 4. 配置Apollo 在`application.properties`或`application.yml`中配置Apollo相关参数： ```yaml apollo: meta: # Apollo Portal的地址 http://localhost:8080 # Apollo AppId appId: myAppId # Apollo配置中心的命名空间 namespace: application ``` 至此，我们就成功地接入了Apollo，实现了Spring依赖注入的Bean动态刷新。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值