Spring框架基础

1.Spring

1.1 简介

  • spring:软件行业的春天

  • 2002年,首次推出Spring框架的雏形:interface21框架!!

  • spring框架以interface21框架为基础,经过不断设计,并不断丰富内涵,于2004年3月四日,发布版本

    • 创始人:Rod johnson Spring Framwork创始人
  • spring设计理念:使现有的技术更加容易使用,本身是一个大杂烩,整合了现有技术的框架。

  • SSH: Struct2+Spring+Hibernate!

  • SSM: SpringMVC + Spring +Mybatis !

1.2 、优点

  • Spring是一个开源的免费的框架(容器)!
  • 是一个轻量级的、非入侵式的框架!
  • 控制反转(IOC)
  • 面向切面(AOP)
  • 支持事务的处理,对框架整合的支持!

总结一句话:Spring就是一个轻量级的控制反转(IOC) 和面向切面编程(AOP)的框架!!

1.3、组成

img

1.4、拓展

  • Spring Boot(构建一切)
    • 一个快速开发的脚手架
    • 一个基于SpringBoot可以快速开发单个微服务
    • 约定大于配置!!!
  • Spring Cloud(协调一切)
    • SpringCloud是基于SpringBoot实现的

因为现在大多数公司都在使用SpirngBoot进行快速开发,学习springboot的前提,就是完全掌握spring以及springmvc!承上启下的作用

2.IOC理论推导

//DAO层
package dao;

public interface UserDao {
    public void getuser();
}



package dao;

public class UserDaoimpl implements UserDao{
    @Override
    public void getuser() {
        System.out.println("我是第一");    }
}


package dao;

public class UserTwoimpl implements UserDao{
    @Override
    public void getuser() {
        System.out.println("我是第二");
    }
}



//service层
package service;

public interface UserService {
    public void getuser();

}

package service;

import dao.UserDao;
import dao.UserDaoimpl;
import dao.UserTwoimpl;

public class UserServiceimpl implements UserService{
    private UserDao userDao =new UserTwoimpl();//这样的话就会非常的麻烦,你需要用哪个包修改new对象

    @Override
    public void getuser() {
        userDao.getuser();

    }
}


//text测试类
 UserServiceimpl userServiceimpl= new UserServiceimpl();
   userServiceimpl.getuser();


//这就是传统的java实现业务逻辑,而在新版的ioc中,完美解决这种冗余的方法



  1. UserDao层 接口
  2. UserDaoimpl 实现类
  3. UserService 业务接口
  4. UserServiceImpl 业务实现类

在我们之前的业务中,用户的需求可能会改变我们原来的代码,我们需要根据用户的需求来修改源代码!!!如果程序代码量十分大,修改一次的成本是十分高额的

  • 我们是用一个set接口
  1. private UserDao userDao;
    
        //利用set进行动态实现值得注入
        //这种方法革命性的改变了代码的复杂性
    	//这就是set方法
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
    //好处是:修改代码不需要改变代码,修改new的方式,现在只需要现货区set接口这个dao层,然后
    
    
    public class Mytest {
        public static void main(String[] args) {
            //业务调取的实际是业务层,dao层不需要接触
            UserServiceimpl userServiceimpl= new UserServiceimpl();
            //userServiceimpl.getuser();
            userServiceimpl.setUserDao(new UserTwoimpl());//只需要改变set里面的实现类即可,不需要让程序主动创建对象了
            userServiceimpl.getuser();
    
        }
    }
    
  • 之前,程序是主动创建对象!!控制权在程序猿手上

  • 使用了set注入后,程序不再拥有主动性,而是变成了被动接受对象

  • 这种思想,从本质上改变了问题,我们程序员不用再去管理对象的创建了。系统的耦合性大大降低,可以全心进入业务的实现上,这是IOC的原型

  • 这就是控制反转:在传统的java中,通常有对象内部的new来创建对象,让程序主动去创建依赖对象,而在ioc中,ioc有专门一个容器,专门用来创建这些对象,所以现在将控制权交给了ioc,即由ioc容器来控制对象的创建

  • 何为正转:传统java中,有我们自己在对象中主动控制去直接获取依赖对象,也就是正转。
  • 何为反转:有容器来帮忙创建及注入依赖对象;有容器来帮助我们查找以及注入依赖对象,对象只是被动地接受依赖对象,依赖对象的获取被反转了[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qesqW9ME-1642507082726)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529180814154.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ENtIgVn8-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529183925684.png)]

<?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">
    <bean id="mysqlimpl" class="dao.UserDaoimpl"></bean><!---->

    <bean id="userd" class="service.UserServiceimpl">
        <!--
        ref:引用Spring容器中创建好的对象
        value:具体的值,基本数据类型
        -->
        <property name="userDao" ref="mysqlimpl"></property>
    </bean>


</beans>
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserServiceimpl;

public class Mytest {
    public static void main(String[] args) {

        //获取ApplicationContext  :拿到spring的容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //容器在手天下我有,需要什么,就直接get什么
        UserServiceimpl userServiceimpl = (UserServiceimpl) context.getBean("userd");
        userServiceimpl.getuser();
    }
}

  • 对象由Spring来创建,管理,装配!!!

3.IOC创建对象的方式

  1. 使用无参构造创建对象,默认!!

  2. 使用有参构造创建对象

    1. 下标赋值

      <!--有参构造如何创建对象。
              采用下标赋值
          -->
          <bean id="user" class="com.pojo.User" >
             <constructor-arg index="0" value="姚海"></constructor-arg>
          </bean>
      
    2. 类型

      <!--有参构造如何创建对象。
              采用类型赋值
      		不推荐使用,因为有个能第二个参数也是string类型,这样不好识别
          -->
          <bean id="user" class="com.pojo.User" >
             <constructor-arg type="java.lang.String" value="姚海"></constructor-arg>
          </bean>
      
    3. 参数名

      <!--有参构造如何创建对象。
              采用参数名赋值
      		推荐使用
          -->
          <bean id="user" class="com.pojo.User" >
             <constructor-arg name="name" value="姚海"></constructor-arg>
          </bean>
      
  3. Spring就相当于一个婚介所,需要创建的对象就将它写在beans容器配置文件中,代替了以前new的方式,但是效果一样

  4. 总结:在配置文件加载的时候,容器中管理的对象就已经被初始化了

4.Spring配置

4.1别名:

  • <alias name="user" alias="userNew"/>
    

4.2、Beam的配置

  • <!--直接在工程里面起别名
    id : bean 的唯一标识符  ,也就是相当于我们学的对象名
    class : bean 对象所对应的全限定名 :包名+ 类型
    name : 也是别名,而且可以起多个别名
    -->
    <bean id="user" class="com.pojo.User" name="us1 us2 us3">
    
        </bean>
    

5.3、import

这个import,一般用于团队开发使用,它可以将多个配置文件,导入合并为一个

  • 将多个beans.xml配置文件合并为一个总的,使用的时候只用使用总的一个
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lKO6ZniU-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529195356728.png)]
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hxD3DQYH-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529195555987.png)]

6、依赖注入

6.1、构造器注入

6.2、set方式注入【重点】

  • 依赖注入:Set注入!!
    • 依赖:bean对象的创建依赖于容器
    • 注入:bean对象中的所有属性,由容器来注入

【环境搭建】

  1. 复杂类型

    package com.yao.pojo;
    
    public class Address {
        private String address;
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "address='" + address + '\'' +
                    '}';
        }
    }
    
    
  2. 真实测试对象

     private String name;
        private Address address;
        private String[] books;
        private List<String> hobbys;
        private Map<String,String> card;
        private Set<String> games;
        private Properties info;
        private String wife;
    
  3. 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"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
      <bean id="student" class="com.yao.pojo.Student">
          <!--第一种,普通值注入,value-->
          <property name="name" value="姚海" ></property>
    
      </bean>
    
    </beans>
    
  4. 测试类

    import com.yao.pojo.Student;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class MyText {
        public static void main(String[] args) {
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            Student student = (Student) context.getBean("student");
            System.out.println(student);
        }
        
    }
    
    
  5. 完善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"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
        <bean id="address" class="com.yao.pojo.Address">
            <property name="address" value="sdasd"></property>
        </bean>
    
    
      <bean id="student" class="com.yao.pojo.Student">
          <!--第一种,普通值注入,value-->
          <property name="name" value="姚海" ></property>
          <!--第二种,Bean注入,ref-->
          <property name="address" ref="address" ></property>
    
          <!--数组注入-->
          <property name="books">
              <array>
                  <value>红楼梦</value>
                  <value>西游记</value>
                  <value>三国演义</value>
              </array>
          </property>
    
          <!--List注入-->
          <property name="hobbys">
              <list>
                  <value>听歌</value>
                  <value>敲代码</value>
                  <value>听歌</value>
              </list>
          </property>
    
          <!--Map注入-->
          <property name="card">
              <map>
                  <entry key="身份证" value="411528" ></entry>
                  <entry key="银行卡" value="411528" ></entry>
              </map>
          </property>
          
          <!--Set-->
          <property name="games">
              <set>
              <value>LOL</value>
                  <value>CBC</value>
                  <value>BOB</value>
              </set>
          </property>
    
          <!--NULL注入-->
          <property name="wife">
    
              <null/>
          </property>
    
          <!--propertys-->
          <property name="info">
              <props>
                  <prop key="driver">2019125</prop>
                  <prop key="url">男</prop>
                  <prop key="username">root</prop>
                  <prop key="password">2019125</prop>
    
              </props>
          </property>
    
      </bean>
    
    </beans>
    

6.3、扩展方式注入

7、c命名和p命名空间注入
p命名:要有第三方的约束
xmlns:p="http://www.springframework.org/schema/p"  标题加上这句
<bean id="user" class="com.yao.pojo.User" p:name="请将" p:age="18">

    </bean>
c命名:构造器注入也要有第三方注入
xmlns:c="http://www.springframework.org/schema/c"

    <!--c命名空间注入,通过构造器注入: c:construct -->
    <bean id="user2" class="com.yao.pojo.User" c:age="18" c:name="姚海"></bean>

scopes:作用域

6.4、bean的作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z1jbZuBk-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210530234624880.png)]

  1. 单例模式(spring默认机制):对象只注入一次,创建多个对象它的实例还是只有一个
<bean id="user" class="com.yao.pojo.User" p:name="请将" p:age="18" scope="singleton">
Student student = (Student) context.getBean("student");
Student student1 = (Student) context.getBean("student");

//使用单例模式:student与student1对象一样

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0R89Ro43-1642507082728)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210530234702495.png)]

  1. 原型模式:每次从容器上get的时候,都会产生一个新对象!!!

    <bean id="user2" class="com.yao.pojo.User" c:age="18" c:name="姚海" scope="prototype"></bean>
    
    Student student = (Student) context.getBean("student");
    Student student1 = (Student) context.getBean("student");
    
    //使用原型模式:student与student1对象是两个新对象
    
  2. 其余的request、session、application、这些只能在web中使用到!!!

7.Bean的自动装配

  • 自动装配是Spring满足bean依赖的一种方式
  • Spring会在上下文中寻找,并自动给beam装配属性

在spirng中有三种装配方式

  1. 在xml中显示的配置

  2. 在java中显示的配置

  3. 隐式的自动装配【很重要】

7.1测试

  1. 环境搭建:一个人有两个宠物!!!

7.2、ByName自动装配

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

    <!--
    byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的 beanid!!
    -->
    <bean id="people" class="com.yao.pojo.People" autowire="byName">
        <property name="name" value="小毛孩啊"></property>
       <!-- <property name="dog" ref="dog"></property>
        <property name="cat" ref="cat"></property>-->
    </bean>

7.3、ByType自动装配

  <bean id="dog" class="com.yao.pojo.Dog"></bean>
    <bean id="cat" class="com.yao.pojo.Cat"></bean>
<!--
	bytype:会自动在容器上下文中查找,和自己对象属性类型相同的bean!!!
    -->

<bean id="people" class="com.yao.pojo.People" autowire="byType">
        <property name="name" value="小毛孩啊"></property>
        <!-- <property name="dog" ref="dog"></property>
         <property name="cat" ref="cat"></property>-->
    </bean>

小结:

  • byname的时候,需要保证bean的idid唯一,并且这个bean需要和自动注入的属性的set方法一致
  • bytype的时候,需要保证所有的bean的class唯一,并且这个bean需要和自动注入的属性的类型一致

7.4、使用注解实现自动装配

jdk1.5支持的注解,spring2.5就开始支持的注解了!!

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

要使用注解须知:

  1. 导入约束 context约束

  2. 配置注解的支持 context:annotation-config/

    <?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
            https://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            https://www.springframework.org/schema/context/spring-context.xsd">
    
        <context:annotation-config/>
    
    </beans>
    

    @Autowired

    在使用该注解时,是将一个类引入到另一个类中,在引入的时候,会自动从IOC池中根据类名去获取

    直接在属性上使用即可!!!也可以在set方法上使用!!

    使用Autowired 我们可以不用编写Set方法了,前提是你这个自动装配的的 属性 在 ioc容器中存在,且符合byname

    科普:

    @Nullable  字段标记了这个注解,说明这个字段可以为null
    
    public class People {
        //如果显示定义了aotowired的required属性为false ,说明这个对象可以为null,否则不允许为空
        @Autowired(required = false)
        private Cat cat;
        @Autowired
        private Dog dog;
        private String name;
    }
    

    一对一 一对多 多对多

    sql语句中列传行 行转列

    @Component:

  • 将该类注入到IOC容器中,其中id默认为该类类名小写

  • 将一个普通bean,将注解的类在容器中创建bean实例

  • //@Component:可以替代bean容器中的书写
    <bean id="dog" class="entry.Dog"></bean>
    
    
  • //需要在bean中输入约束
    <context:component-scan base-package="com.yao.pojo"/>
    <!--bean中扫描包-->
    
  • 所有的注解都跟IOC容器挂钩

    @Data @AllArgsConstruetor @NoArgsConstau

  • 该注解写在类中可以代替所有set/get方法的构建

    //在maven中引入lombok
    
    lombok
        
    

@Qualifier

  • 当有多个对象时候,指定其中一个

  • <!--bean中有多个对象时候-->
    <bean id="dog222" class="com.yao.pojo.People"/>
        <bean id="dog111" class="com.yao.pojo.Dog"/>
        <bean id="dog333" class="com.yao.pojo.Dog"/>
    
  • @Autowired
    @Qualifier(value ="dog222")//如果有多个对象且类型相同,该注解可以指定其中一个
    private Dog dog;
    

如果@Autowirde自动装配的环境比较复杂,自动装配无法通过一个注解[@Autowirde]完成的时候,我们可以使用@Qualifier(value = “xxx”)

去配置@Autowirde的使用,指定一个唯一的bean对象注入。

@Resource

@Resource(value = “”)不指定value值得话需要 对象和bean中的id一样才能查找到 指定value值则需要跟beanid对应

  • 不属于spirng,java中的一个原注解,可以
  • @Resource通过byname实现,如果找不到名字,则通过Bytype
  • 是一个@Autowirde和@Qualifier的结合体

小结:两者的区别

  • 都是用来自动装配的,都可以放在属性字段上

  • @Autowirde通过byType实现、、而且必须要求这个对象存在 【常用】

  • @Resource通过byname实现,如果找不到名字,则通过Bytype、、如果两个都找不到,就报错【常用】

  • 执行顺序不同:

    • @Autowirde通过ByType的方式实现

8.使用注解开发

在Spring4之后,要使用注解开发,必须要保证 aop 的包导入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GIs2JdEC-1642507082728)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210531165618701.png)]

使用注解需要导入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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!---->
    <context:annotation-config/>
    <!--指定要扫描的包,这个包下的注解就会生效-->
    <context:component-scan base-package="com.yao.pojo"/>
  1. bean

  2. 属性如何注入

    @Value("dsad")//该注解可给属性赋值
    private String name;
    //相当于<property name = "name" value="dsad"/>
    
     
    @Value("dsad")//该注解可给属性赋值
    public void setName(String name){
    	this.name = name;
    }
    
  3. 衍生的注解

    @Component有几个衍生的注解,在我们web的开发中,会按照mvc三层架构分层

    • dao【@Repository】

    • service【@Service】

    • controller【@Controller】

    • 三个注解要用到包扫描然后注册到bean里面

    • <context:component-scan base-package="com.yao.pojo.*"/><!--代表了这个包下的几个层注册到bean里面,这是包扫描->
      

    这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean

  4. 自动装配置

    - @Autowired : 自动装配通过类型 。名字
        如果@Autowirde不能唯一自动装配上属性,则需要通过@Qualifier(value="xxx)
    - @Nullable  字段标记了这个注解,说明这个字段可以为null
    - @Resource :自动装配通过名字。类型
    
  5. 作用域

    @Scope(“prototype”)原型模式

    @Scope(“singleton”)单例模式

    在类开头使用

  6. 小结

    xml与注解:

    • xml更加万能,适用于任何场合!维护简单方便
    • 注解 ! 不是自己的类使用不了,维护相对复杂

    最佳实践:

    • xml用来管理bean

    • 注解只负责完成属性的注入

    • 我们在使用的过程中,只需要注意一个问题,必须让注解生效,就需要开启注解的支持

      <!--指定要扫描的包,这个包下的注解就会生效-->
      <context:component-scan base-package="com.kuang"/>
      <context:annotation-config/>
      

9、使用Java的方式配置Spring

我们现在要完全不适用Spring的xml的配置了,全权交给Java来做!!!

JavaConfig 是Spring的一个子项目,在Spring 4之后,它成为了一个核心功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afir7i7C-1642507082728)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210531230510544.png)]

1.一个是用注解配置的上下文

2.classpath配置的上下文

实体类

package com.yao.pojo;

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

//这里这个注解的意思,就是说明这个类被Spirng接管了,注册到了容器中
@Component
public class User {

    private String name;

    public String getName() {
        return name;
    }
    @Value("姚海")//属性的注入值
    public void setName(String name) {
        this.name = name;
    }

    public User() {

    }

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

配置文件

package com.yao.config;


import com.yao.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
//这个也会被Spirng容器托管,因为他本身就是一个@Component,@Configuration代表这是一个配置类,就和我们之前看的beans.xml一样的
@ComponentScan("com.yao.pojo")
//扫描包

public class Yaoconfig {
    //注册一个Bean  ,  就相当于我们之前写的一个bean标签
    //这个方法的名字,就相当于bean标签中的id属性
    //这个方法的返回值,就相当于
   @Bean
    public User user(){
       return new User();//就是返回要注入到bean的对象!!
   }

}

测试类

package com.yao;

import com.yao.config.Yaoconfig;
import com.yao.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyText {
    public static void main(String[] args) {
        //如果完全使用了配置类方式去做,我们就只能通过AnnotationConfig  上下文来获取容器,通过配置类的class对象加载
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Yaoconfig.class);
        User getUser = (User)applicationContext.getBean("user");
        System.out.println(getUser.getName());

    }
}

这种纯Java的配置方式,在SpringBoot中随处可见!!!

10.动态代理

/扫描包

public class Yaoconfig {
//注册一个Bean , 就相当于我们之前写的一个bean标签
//这个方法的名字,就相当于bean标签中的id属性
//这个方法的返回值,就相当于
@Bean
public User user(){
return new User();//就是返回要注入到bean的对象!!
}

}


测试类

```java
package com.yao;

import com.yao.config.Yaoconfig;
import com.yao.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyText {
    public static void main(String[] args) {
        //如果完全使用了配置类方式去做,我们就只能通过AnnotationConfig  上下文来获取容器,通过配置类的class对象加载
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Yaoconfig.class);
        User getUser = (User)applicationContext.getBean("user");
        System.out.println(getUser.getName());

    }
}

这种纯Java的配置方式,在SpringBoot中随处可见!!!

10.动态代理

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值