spring IOC依赖注入笔记

最新推荐文章于 2022-11-18 12:43:04 发布
最新推荐文章于 2022-11-18 12:43:04 发布
阅读量141 收藏
点赞数
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44007213/article/details/117448973
版权

通用的spring pom.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
         https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

p命名和C命名空间的注入：

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

注解配置需要导入的：

1、在spring配置文件中引入context文件头

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

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

2、开启属性注解支持！

<context:annotation-config/>

3.指定注解扫描包

<!--指定注解扫描包-->
<context:component-scan base-package="com.kuang.pojo"/>

2.IOC（控制反转）

控制反转简而言之就是将创建对象的权力交给了spring去做，这样我们就直接找spring去拿就好了，而IOC的是实现方式就是依赖注入。这样做的优势就是方便解耦。在没有IOC的情况下，对象和对象的依赖关系是完全硬编码在代码之中，通过使用IOC，用第三方spring来管理我们的对象，这样就实现了解耦。
IOC的实现方式有很多种，比如最开始的xml，到后来出现的注解，再到最新版本的完全使用注解（0配置实现ioc）。
2.1 用xml实现依赖注入
1.先导入spring对应的jar包

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

重用导入这一个jar包，其他的几个jar包会一起依赖导入。如图：
在这里插入图片描述

有参和无参构造器注册bean，让spring管理

通过无参构造函数注册

<!--bean就是java对象 , 由Spring创建和管理-->
   <bean id="hello" class="com.kuang.pojo.Hello">
       <property name="name" value="Spring"/>
   </bean>
  • bean：就是java对象，表示由spring创建和管理。
  • id：全局唯一
  • class：代表要被spring管理的类
  • property：表示属性。如果是基本类型的，用value注入。如果是引用类型的用ref注入
	<bean id="hello" class="com.kuang.pojo.Hello">
		<property name="name1" value="Spring1"/>
       <property name="name2" ref="Spring2"/>
   </bean>
  • 其中name为属性。属性依赖于对应的生成的set方法后面的字符串（首字母小写）。所以用这样的方法注入必须生成对应的set方法。

通过有参构造函数注册

public class UserT {

   private String name;

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

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

   public void show(){
       System.out.println("name="+ name );
  }
  
}

有对应的三种有参构造方式实现方法：

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- index指构造方法 , 下标从0开始 -->
   <constructor-arg index="0" value="kuangshen2"/>
</bean>
<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="kuangshen2"/>
</bean>
<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <constructor-arg type="java.lang.String" value="kuangshen2"/>
</bean>

import方法

在团队合作的时候，可能有好几个pom.xml文件，如果要汇总成一个，就得用import

<import resource="{path}/beans.xml"/>

其他数据类型的注入：

  • 常量

  • 引用

  • 数组

  • list

  • map

  • set

  • null

  • properties

对应的实现：
1.常量

 <bean id="student" class="com.kuang.pojo.Student">
     <property name="name" value="小明"/>
 </bean>

2.引用

 <bean id="addr" class="com.kuang.pojo.Address">
     <property name="address" value="重庆"/>
 </bean>
 
 <bean id="student" class="com.kuang.pojo.Student">
     <property name="name" value="小明"/>
     <property name="address" ref="addr"/>
 </bean>

3.数组

 <bean id="student" class="com.kuang.pojo.Student">
     <property name="name" value="小明"/>
     <property name="address" ref="addr"/>
     <property name="books">
         <array>
             <value>西游记</value>
             <value>红楼梦</value>
             <value>水浒传</value>
         </array>
     </property>
 </bean>

4.list

 <property name="hobbys">
     <list>
         <value>听歌</value>
         <value>看电影</value>
         <value>爬山</value>
     </list>
 </property>

5.map

 <property name="card">
     <map>
         <entry key="中国邮政" value="456456456465456"/>
         <entry key="建设" value="1456682255511"/>
     </map>
 </property>

6.set

 <property name="games">
     <set>
         <value>LOL</value>
         <value>BOB</value>
         <value>COC</value>
     </set>
 </property>

7.null

 <property name="wife"><null/></property>

8.properties

 <property name="info">
     <props>
         <prop key="学号">20190604</prop>
         <prop key="性别">男</prop>
         <prop key="姓名">小明</prop>
     </props>
 </property>

p命名和c命名注入：

1.p命名空间注入：需要加入约束文件
p命名注入是不需要有参构造器的

 导入约束 : xmlns:p="http://www.springframework.org/schema/p"
 <!--P(属性: properties)命名空间 , 直接注入属性-->
 <bean id="user" class="com.kuang.pojo.User" p:name="abc" p:age="18"/>

2.c名命名空间注入：需要加入约束文件
c命名空间注入需要有参构造器，不然会报错

 导入约束 : xmlns:c="http://www.springframework.org/schema/c"
 <!--C(构造: Constructor)命名空间 , 使用构造器注入-->
 <bean id="user" class="com.kuang.pojo.User" c:name="abc" c:age="18"/>

以上的p命名和c命名就是无参构造和有参构造的一个简写，方便偷懒。

bean的作用域

scope:指对象的作用范围，取值如下：

取值范围说明
singleton默认值，单例的
prototype多例的
requestWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
sessionWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global sessionWEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

1）当scope的取值为singleton时

​ Bean的实例化个数：1个

​ Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

​ Bean的生命周期：

对象创建：当应用加载，创建容器时，对象就被创建了

对象运行：只要容器在，对象一直活着

对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2）当scope的取值为prototype时

​ Bean的实例化个数：多个

​ Bean的实例化时机：当调用getBean()方法时实例化Bean

对象创建：当使用对象时，创建新的对象实例

对象运行：只要对象在使用中，就一直活着

对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

4. spring相关API

4.1 ApplicationContext的继承体系

applicationContext：接口类型，代表应用上下文，可以通过其实例获得 Spring 容器中的 Bean 对象

4.2 ApplicationContext的实现类

1）ClassPathXmlApplicationContext

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

2）FileSystemXmlApplicationContext

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

3）AnnotationConfigApplicationContext

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

4.3 getBean()方法使用

public Object getBean(String name) throws BeansException {  
	assertBeanFactoryActive();   
	return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException {
	assertBeanFactoryActive();
	return getBeanFactory().getBean(requiredType);
}

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错

getBean()方法使用

ApplicationContext applicationContext = new 
            ClassPathXmlApplicationContext("applicationContext.xml");
  UserService userService1 = (UserService) applicationContext.getBean("userService");
  UserService userService2 = applicationContext.getBean(UserService.class);

自动装配

组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。
Spring的自动装配需要从两个角度来实现，或者说是两个操作：
1.组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
2.自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；

实验
1.新建两个实体类，Cat Dog 都有一个叫的方法

public class Cat {
   public void shout() {
       System.out.println("miao~");
  }
}
public class Dog {
   public void shout() {
       System.out.println("wang~");
  }
}

2.新建一个用户类 User

public class User {
   private Cat cat;
   private Dog dog;
   private String str;
}

3.编写Spring配置文件

<?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">

   <bean id="dog" class="com.kuang.pojo.Dog"/>
   <bean id="cat" class="com.kuang.pojo.Cat"/>

   <bean id="user" class="com.kuang.pojo.User">
       <property name="cat" ref="cat"/>
       <property name="dog" ref="dog"/>
       <property name="str" value="qinjiang"/>
   </bean>
</beans>

4.测试

public class MyTest {
   @Test
   public void testMethodAutowire() {
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       User user = (User) context.getBean("user");
       user.getCat().shout();
       user.getDog().shout();
  }
}

实验结果完全ok。

刚才的结果展示了我们手动装配dog和cat。现在我们通过xml自动装配dog和cat。

byname xml装配

1、修改bean配置，增加一个属性 autowire=“byName”

<bean id="user" class="com.kuang.pojo.User" autowire="byName">
   <property name="str" value="qinjiang"/>
</bean>

2、再次测试，结果依旧成功输出！

3、我们将 cat 的bean id修改为 catXXX

4、再次测试， 执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方法，真正的setCat就没执行，对象就没有初始化，所以调用时就会报空指针错误。

小结：

当一个bean节点带有 autowire byName的属性时。

  1. 将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。

  2. 去spring容器中寻找是否有此字符串名称id的对象。

  3. 如果有，就取出注入；如果没有，就报空指针异常。

byType xml装配

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

测试：

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User" autowire="byType">
   <property name="str" value="qinjiang"/>
</bean>

刚才的结果展示了我们xml自动装配dog和cat。现在我们通过注解自动装配dog和cat。

1、在spring配置文件中引入context文件头

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

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

2、开启属性注解支持！

<context:annotation-config/>

@Autowired

  • @Autowired是按类型自动转配的，不支持id匹配。
  • 需要导入 spring-aop的包！

测试：
1、将User类中的set方法去掉，使用@Autowired注解

public class User {
   @Autowired
   private Cat cat;
   @Autowired
   private Dog dog;
   private String str;

   public Cat getCat() {
       return cat;
  }
   public Dog getDog() {
       return dog;
  }
   public String getStr() {
       return str;
  }
}

2.此时的配置文件的内容

<context:annotation-config/>

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="user" class="com.kuang.pojo.User"/>

@Qualifier

  • @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
  • @Qualifier不能单独使用。

测试：
1、配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！

<bean id="dog1" class="com.kuang.pojo.Dog"/>
<bean id="dog2" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

2、没有加Qualifier测试，直接报错
3、在属性上添加Qualifier注解

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

这样就好啦

还有一个跟@Autowired功能类似的注解叫做
@Resource

  • @Resource如有指定的name属性，先按该属性进行byName方式查找装配；
  • 其次再进行默认的byName方式进行装配；
  • 如果以上都不成功，则按byType的方式自动装配。
  • 都不成功，则报异常。

测试：
实体类：

public class User {
   //如果允许对象为null，设置required = false,默认为true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

xml配置文件

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

<bean id="user" class="com.kuang.pojo.User"/>

配置文件2：beans.xml ， 删掉cat2

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat1" class="com.kuang.pojo.Cat"/>

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog dog;

结果：OK

结论：先进行byName查找，失败；再进行byType查找，成功。

小结

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

使用Spring原始注解开发
上面讲了如何使用xml和注解的自动装配，而Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。
Spring原始注解主要是替代 Bean 的配置

注解说明
@Component使用在类上用于实例化Bean
@Controller使用在web层类上用于实例化Bean
@Service使用在service层类上用于实例化Bean
@Repository使用在dao层类上用于实例化Bean
@Autowired使用在字段上用于根据类型依赖注入
@Qualifier结合@Autowired一起使用用于根据名称进行依赖注入
@Resource相当于@Autowired+@Qualifier，按照名称进行注入
@Value注入普通属性
@Scope标注Bean的作用范围
@PostConstruct使用在方法上标注该方法是Bean的初始化方法
@PreDestroy使用在方法上标注该方法是Bean的销毁方法

在spring4之后，想要使用注解形式，必须得要引入aop的包
在这里插入图片描述
在配置文件当中，还得要引入一个context约束

<?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: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">

</beans>

1.配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.kuang.pojo"/>

2.在指定包下编写类，增加注

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   public String name = "秦疆";
}

3.测试

@Test
public void test(){
   ApplicationContext applicationContext =
       new ClassPathXmlApplicationContext("beans.xml");
   User user = (User) applicationContext.getBean("user");
   System.out.println(user.name);
}

使用注解注入属性
1、可以不用提供set方法，直接在直接名上添加@value(“值”)

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   @Value("秦疆")
   // 相当于配置文件中 <property name="name" value="秦疆"/>
   public String name;
}

2、如果提供了set方法，在set方法上添加@value(“值”)

@Component("user")
public class User {

   public String name;

   @Value("秦疆")
   public void setName(String name) {
       this.name = name;
  }
}

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：
非自定义的Bean的配置：< bean>

加载properties文件的配置：<context:property-placeholder>

组件扫描的配置：<context:component-scan>

引入其他文件：< import>

注解说明
@Configuration用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
@ComponentScan用于指定 Spring 在初始化容器时要扫描的包。 作用和在 Spring 的 xml 配置文件中的 <context:component-scan base-package=“com.itheima”/>一样
@Bean使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource用于加载.properties 文件中的配置
@Import用于导入其他配置类

@Configuration

@ComponentScan

@Import

@Configuration //表明这是一个配置注解类
@ComponentScan("com.itheima") //相当于这句话<context:component-scan base-package="com.itheima"></context:component-scan>
@Import({DataSourceConfiguration.class}) //导入分配置类
public class SpringConfiguration {
}

@PropertySource

@value

@Bean

@PropertySource("classpath:jdbc.properties") //相当于这句<context:property-placeholder location="xx.properties"/>
public class DataSourceConfiguration {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

@Bean(name="dataSource") //相当于<bean id="datasource" class="getDataSource"> 因为Datasource不可能在源码上写入注解，所以只能创建一个方法返回我们需要的类，在方法上标上<bean>表示这个返回值是交给spring管理的bean。
public DataSource getDataSource() throws PropertyVetoException { 
    ComboPooledDataSource dataSource = new ComboPooledDataSource(); 
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);
    return dataSource;
}

通过以上的注解配置，就可以实现零xml配置spring。在spring boot里边，基本上都是零配置。

不过普通话一乙不改名
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring之IoC容器和依赖注入(1)
qq_36116242的博客
02-20 516
1. IoC的概念 本质上就是工厂模式 以前 以前我们是由自己主动创建一个对象，主动获取一个资源 //Car是接口, 后面是实现类 Car bmw = new Bmw(); Car benZ = new BenZ(); Car audi = new Audi(); 现在 使用工厂模式，我们需要的对象由工厂去创建，我们不再自己创建，我们只消费对象。 Car bmw = BeanFactory.getBean("bmw"); Car benZ = BeanFactory.getBean("be
Spring实现Ioc的多种方式--控制反转、依赖注入、xml配置的方式实现IoC、对象作用域...
weixin_30763397的博客
11-06 95
Spring实现Ioc的多种方式 一、IoC基础 　　1.1、概念： 　　　　1、IoC 控制反转（Inversion of Control） 　　　　　　IoC是一种设计思想。 　　　　2、DI 依赖注入 　　　　　　依赖注入是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法 　　　　没有IoC的程序中我们使用面向对象编程对象的创建与对象间的依赖关系完全硬编码在程序中，对...
Spring学习
weixin_52812293的博客
11-17 351
Spring学习笔记
spring的applicationContext.xml
weixin_41588185的博客
09-23 278
<?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:context="http://www.springframework.org/schema/context" xsi:schemaL.
spring之基于p命名c命名空间的注入
最新发布
qq_42338744的博客
11-18 677
P命名空间注入：目的：简化set方法注入在XML头部信息中添加p命名空间的配置信息：xmlns:p=“http://www.springframeworl.org/schema/p”p命名空间注入是基于setter方法的，所以需要对应的属性提供set方法c命名空间注入：目的：简化构造方法在XML头部信息中添加p命名空间的配置信息：xmlns:c=“http://www.springframeworl.org/schema/c”c命名空间注入是基于构造方法的，所以需要提供构造方法。
Spring_IoC入门笔记.md
05-29
依赖注入：Dependency Injection IOC的作用：降低程序间的偶合（依赖关系） 依赖关系的管理：以后都交给spring来维护 在当前类需要用到其他类的对象时，由spring为我们提供，我们只需在配置文件中说明 依赖关系...
Spring IOC 笔记
03-18
Spring 框架是 Java 应用开发中的核心框架，它引入了控制反转（Inversion of Control，简称 IOC）和依赖注入（Dependency Injection，简称 DI）的概念，极大地简化了组件之间的依赖关系管理。在这个笔记中，我们将...
Spring AOP IOC源码笔记.pdf
05-08
Spring框架是Java开发中不可...总结，Spring框架的IoC和AOP特性极大地简化了Java开发，通过依赖注入解耦了组件，通过面向切面编程解决了共性问题。理解并熟练掌握这些概念和机制，对于提升开发效率和代码质量至关重要。
Spring-IoC 复习笔记.rar
10-23
Spring 框架是 Java 开发中不可或缺的一部分，其核心特性之一就是依赖注入（Dependency Injection，简称 DI），也称为控制反转（Inversion of Control，简称 IoC）。IoC 是一种设计模式，它允许我们通过外部配置来...
Spring IOC和AOP代码与笔记整理
12-07
2. **依赖注入（DI，Dependency Injection）**：是IOC的实现方式，通过setter方法、构造器或接口的实现来注入依赖对象，使得对象之间的耦合度降低，增强了代码的可测试性和可维护性。 3. **Spring容器**：有...
Spring的配置文件ApplicationContext.xml配置头文件解析
热门推荐
m0_37027631的博客
12-16 1万+
spring中的applicationContext.xml配置头文件解析 xml version="1.0" encoding="UTF-8"?> beans xmlns="http://www.springframework.org/schema/beans"      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instan
Spring框架IOC基础及XML的配置 第二章
m0_55668402的博客
03-10 358
1 Spring概述 1.1 关于框架 框架的概念 框架：特指软件框架，它是我们在实际开发中解决项目需求的技术集合。运用框架可以大大简化代码的编写，缩短开发周期。同时，对后续负责项目维护的人员降低技术门槛，对系统升级提供灵活可控的标准。当然，框架提高了我们的开发效率，降低了维护成本的同时，也要求我们需要遵循它的规范，要按照它的要求进行代码的编写。 框架的作用 提高开发效率 增强代码的可重用性 节约维护成本 提供编写规范 解耦顶层实现原理 学好框架的必要性 首先，Spring（包括：springmvc、s
spring所需的配置文件
weixin_45761641的博客
11-23 1480
1、 beans.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
Spring配置文件之引入命名空间
hhx_echo的博客
07-25 1万+
如何为Spring配置文件引入命名空间是我在初接触Spring时有点头疼的问题。现在稍作整理（一）Spring配置文件的最简格式<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/X
狂神说Spring04：自动装配
byteyoung
09-17 487
Bean的自动装配 自动装配说明 自动装配是使用spring满足bean依赖的一种方法 spring会在应用上下文中为某个bean寻找其依赖的bean。 Spring中bean有三种装配机制，分别是： 在xml中显式配置； 在java中显式配置； 隐式的bean发现机制和自动装配。 这里我们主要讲第三种：自动化的装配bean。 Spring的自动装配需要从两个角度来实现，或者说是两个操作： 组件扫描(component scanning)：sp
Spring 导入配置文件的两种方式
小么飞刀的博客
10-30 1895
1.在Spring配置文件中引入properties文件 在application.xml中添加 xmlns:context="http://www.springframework.org/schema/context" http://www.springframework.org/schema/context http://www.springframework.org/sch
spring大厂高频面试题及答案
码猿技术专栏
05-07 2619
Spring概述（10）什么是spring?Spring是一个轻量级Java开发框架，最早有Rod Johnson创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。它是...
Spring构造注入&注解注入&AOP
Yuncoco的博客
06-23 1453
一、依赖注入 1.导包 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocatio...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值