Spring学习笔记(2)

最新推荐文章于 2024-07-20 22:09:47 发布
最新推荐文章于 2024-07-20 22:09:47 发布
阅读量771 收藏 2
点赞数 1
分类专栏： Spring 文章标签： spring bean autowired object ioc class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaojianfengye1/article/details/7987497
版权

1.   装配各种类型的属性

1.1简单属性

使用<bean>的value属性或<property>子标签<value>装配。

<propertyname="name"value="张无忌"></property>

<!-- property元素中的内容叫属性值，会自动把value描述的值转换成对应属性的类型 -->

<propertyname="age"><value>68</value></property>

<!-- 也可以使用value来装配一些Spring支持的类型URL,Class -->

<propertyname="homePage"value="http://www.baidu.cn"></property>

1.2引用其它bean

使用ref属性或标签。

<propertyname="parent">

<!-- ref引用其它的 bean，local表示引用本容器中的bean，parent表示引用父容器中某个bean，bean表示引入某个bean,先在当容器中找，然后再到父容器中找 -->

<refbean="p0"/></property>

1.3内部bean

直接使用<bean>定义一个新的bean,一般不用指定该bean的名称。

<propertyname="parent">

<!-- 值是内部Bean ，一般不需要指定bean的名称 -->

<beanclass="cn.itcasg.gz.springioc.Person">

<constructor-argvalue="张三丰"></constructor-arg>

</bean>

</property>

1.4装配集合

1）数组

          <!-- 装配数组 -->

          <propertyname="favs">

                <array><!--也可以使用<list>标签 -->

                     <value>足球</value>

                     <value>蓝球</value>

                     <value>音乐</value>

                </array>

           </property>

2）List

          <!-- 装配list -->

          <propertyname="schools">

                <list><!--也可以使用<array>标签 -->

                     <value>北大</value>

                     <value>清华</value>

                </list>

           </property>

3）Set

          <!-- 装配set -->

          <propertyname="citys">

                <set>

                     <value>广州</value>

                     <value>北京</value>

                     <value>西安</value>

                     <value>广州</value><!--最终方set中的只有三个元素-->

                </set>

           </property>

4）Map

          <!-- 装配Map -->

          <propertyname="scores">

                <map>

                     <entry key="语文"value="50"/>

                     <entry key="数学"value="30"/>

                     <entry key="历史"value="20"/>

                     <!-- key-ref，value-ref属性用来引用其它bean -->

                     <entry key-ref="p1"value-ref="p2"/>

                </map>

           </property>

5）Properties

          <!-- 装配属性类型 -->

          <propertyname="ims">

          <props>

          <prop key="qq">4858458</prop>

          <prop key="msn">caishiyou@sina.com</prop>

          </props>

          </property>

          <!-- 在value中直接使用键值对来作为属性内容 -->

          <propertyname="ims2">

                <value>

                     qq=58568565868

                     msn=kdkdkf@ddd.com

                </value>

            </property>

1.5装配空值null

      <bean id="p2"class="cn.itcasg.gz.springioc.Person">

          <propertyname="name"value="小链子"/>

          <propertyname="age">

                <!-- null标签用来指定空值 -->

                <null/>

          </property>

      </bean>

1.6装配复杂类型属性

publicclass Person {

      private Stringname;

      private Integerage;

      private Personparent; //父亲，复杂类型

      private Datebirthday; //生日,复杂类型

}

1） 使用value来注入复杂类型的对象

如果使用value来注入复杂类型的对象，要依赖的对象提供带一个参数（并且类型为String)的构造函数，Spring就可以将其转换成需要的类型。

 

      <bean id="p1"class="com.maple.spring.customtype.Person">

          <propertyname="name"value="张三"/>

          <propertyname="age"value="23"/>

          <!-- parent为Person类型，如果使用value来注入复杂类型的对象只要

依赖的对象提供带一个参数（并且类型为String)的构造函数，Spring就可以将其转换成需要的类型。 -->

          <propertyname="parent"value="李四/>

      </bean>

2）自定义类型编辑器

 

使用value来注入复杂类型对象时，是不完整的。这时就要自定义类型编辑器，自定义类型编辑器时继承PropertyEditorSupport类，并重写其setAsText方法。

publicclass MyDateEditorextendsPropertyEditorSupport {

//   PropertyEditorSupport的子类中有日期编辑器

      private SimpleDateFormatsdf = new SimpleDateFormat("yyyy-MM-dd");

      @Override

      publicvoid setAsText(Stringtext)throws IllegalArgumentException {

          System.out.println("执行编辑器的setAsText方法....");

          if(text !=null &&text.trim().length() > 0) {

                try {

                     Datedate = sdf.parse(text);//转换

                     this.setValue(date);//将转换后的值设置进去

                }catch (ParseException e) {

                     e.printStackTrace();

                     super.setAsText(text);

                }

          }    

      }

}

3)注册自定义编辑器

      <!-- 注册类型编辑器,从BeanFactoryPostProcessor接口的实现类 -->

<beanclass="org.springframework.beans.factory.config.CustomEditorConfigurer">

          <!--customEditors是该类的一个Map类型属性 -->

          <propertyname="customEditors">

                <map>

<!-- key:要转换的类型 value:指定使用哪个转换器来转换 -->

<entrykey="java.util.Date"value="com.maple.spring.customtype.MyDateEditor"/>

                </map>

          </property>

      </bean>

2.注解装配解决方案1(XML+注解配合)

用法：xml用来定义Bean的信息;注解用来配置依赖信息。

使用到的标签：

@Resource(Java标签的资源注解)（推荐使用）

@Autowired(Spring自定的注解)，注解可以加在setter方法上(setter注入)／可以加在Field上(Field注入)。

@Autowired－－按类型注入。required=false用来指定该依赖的对象是否是必须的。（false非必须，true必须的，默认true）。

@Qualifier("personDao2")--用来指定要注入的Bean叫什么名字，与@Autowired配合使用。

      @Autowired

      @Qualifier("personDao2")//要注入的Bean的名称为personDao2，会到IoC容器中找

      publicvoid setDao(IPersonDaodao) {

          this.dao = dao;

      }

@Resource--按名字注入,找到名字相同，则直接注入。找不到名字相同，则找类型。可在使用name属性来指定要注入的Bean的名称如:@Resource(name=”personDao”)。

      //要注入的Bean的名称为personDao，会到IoC容器中找

      @Resource(name="personDao")

      publicvoid setDao(IPersonDaodao) {

          this.dao = dao;

      }

 

beans.xml:

<?xmlversion="1.0"encoding="UTF-8"?>

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

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

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-3.0.xsd

http://www.springframework.org/schema/context

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

      <!-- 开启注解配置，必能省，注意加入context命名空间 -->

     <context:annotation-config/>

      <bean id="personDao"class="cn.itcasg.gz.springioc.PersonDaoImpl"/>

      <bean id="personDao2"class="cn.itcasg.gz.springioc.PersonDaoImpl"/>

      <bean id="dao"class="cn.itcasg.gz.springioc.Person"/>

      <bean id="personService"class="cn.itcasg.gz.springioc.PersonServiceImpl"/>

</beans> 

3.注解装配解决方案2(完全使用注解)

1）指定到IoC容器中的业务组件

在实现类上添加注解:

@Repository(持久层组件）

@Service(业务层的组件)

@Controller(控件层组件)

@Component(不属于以上三层的组件)

 

放到容器中的Bean的名字默认是类名首字母变小写，使用value属性就可以指定具体的Bean名称。如：@Service("personService")bean的名字为personService。

 

Bean的作用域：默认是单例singleton。其它作用域，则配合使用@Scope标签来指定。

如：@Scope("prototype")

@Service("personService")//存在在容器中bean的名字为personService

@Scope("prototype")//Bean的作用域为propotype，默认是singleton

publicclass PersonServiceImpl2implements IPersonService {

....//省略

}

2)给组件指定依赖

使用@Autowire或@Resource标签来指定。

      //要注入的Bean的名称为personDao，会到IoC容器中找

      @Resource(name="personDao")

      publicvoid setDao(IPersonDaodao) {

          this.dao = dao;

      }

3）启动Spring的注解扫描功能

在配置文件中使用<context:component-scan>指定让Spring去扫描哪些包，从而找到要放到容器中的组件。

<!-- 指定Spring去扫描哪些包

如果这些包及其子包下面的类有@Service等标签，则把其放到容器管理

base-package中如果有多个包可使用逗号(,)或分号(;)隔开。要加入context命名空间-->

<context:component-scanbase-package="com.maple.annotation1,com.maple.annotation2"/>

4.容器扩展点及应用

Spring提供了一些接口，让开发者通过这些接口可以扩充容器的功能。如常用的BeanFactoryPostProcessor和BeanPostProcessor口。

4.1自定义类型编辑器

参见1.6  2)和3）。

4.2 BeanFactoryPostProcessor接口(创建Bean前)

实现了该接口的子类要重写其postProcessBeanFactory方法，该方法在配置信息加载完以后，Bean对象初始化之前调用，可以在创建Bean之前过滤信息。

1）写一个类实现该接口，并重写postProcessBeanFactory方法。

publicclassMyBeanFactoryPostProcessorimplementsBeanFactoryPostProcessor {

@Override//该方法在配置信息加载完以后，Bean对象初始化之前调用

publicvoidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throws BeansException {

          //可以在创建Bean之前过滤信息

System.out.println("该方法在配置信息加载完以后，Bean对象初始化之前调用");

      }

}

2）在配置文件注册该类。

      <!-- 注册自定义BeanFactoryPostProcessor子类，该类在所有的Bean创建之前都会执行其postProcessBeanFactory方法(只执行一次) -->

<beanclass="com.maple.spring.customtype.MyBeanFactoryPostProcessor"/>

4.3 BeanPostProcessor接口(创建Bean之后)

1）写一个类实现该接口，并重写postProcessBeforeInitialization方法

和postProcessAfterInitialization方法。

publicclassMyBeanPostProcessorimplements BeanPostProcessor{

      @Override//该方法会在每个Bean创建好之后执行，执行完接着执行postProcessAfterInitialization方法

      public ObjectpostProcessBeforeInitialization(Object bean, String beanName)throws BeansException {

          System.out.println("处理Bean前...");

          return bean;//处理完后要返回原来的bean

      }

      @Override

      public ObjectpostProcessAfterInitialization(Object bean, String beanName)throws BeansException {

          System.out.println("处理Bean后...");

          return bean;//处理完后要返回原来的bean

      }

}

 

2） 在配置文件注册该类。

<!-- 注册自定义BeanPostProcessor子类，该类在每个Bean创建好都会执行其

postProcessBeforeInitialization方法和postProcessAfterInitialization方法 (会执行多次) -->

<beanclass="com.maple.spring.customtype.MyBeanPostProcessor"/>

4.4使用Spring来加载配置文件

      <!-- 加载properties类型的文件的内容 -->

<beanclass="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

          <propertyname="location"value="db.properties"/>

      </bean>

      <!-- 下面是简化的方案 -->

      <context:property-placeholderlocation="db.properties"/>

      <!-- 使用已有的扩展点来扩展一些功能 -->

      <!-- 配置模拟数据源 -->

      <bean id="dataSource"class="cn.itcast.gz.springioc.MyDataSource">

          <propertyname="url"value="${db.url}"/>

          <propertyname="driverClass"value="${db.driverClass}"/>

          <propertyname="username"value="${db.username}"/>

          <propertyname="password"value="${db.password}"/>

      </bean>

说明：使用了context:property-placeholder后，Spring可以是根据${xxx}可以的内容到xxx.properties文件中找对应的值并设置到value上。

5. 工厂Bean(FactoryBean)

FactoyBean(接口)是一个专用于生产其它类型业务组件的Bean，用于生产其它产品的Bean。

注意：FactoyBean和BeanFactoy是两个完全不同的接口。前者专门用来生产Bean，后者专门用来获取Bean。

1） 自定义工厂Bean

自定义工厂Bean要实现FactoryBean接口。

publicclass PersonFactoryBeanimplementsFactoryBean<Person> {

      @Override

      public PersongetObject() throws Exception {

          System.out.println("getObject..........");

          //返回一个Person类型的Bean

          returnnew Person("张三");

      }

      @Override

      publicClass<Person> getObjectType() {

          //返回该Bean的类型

          System.out.println("getObjectType..........");

          return Person.class;

      }

      @Override

      publicboolean isSingleton() {

          //该Bean是否是单例的

          System.out.println("isSingleton..........");

          returnfalse;

      }

}

2） 在配置文件注册该类。

      <!-- 注册自定义工厂Bean 根据id值pfb获取的bean的类型不再是PersonFactoryBean类型，而是由PersonFactoryBean类中的getObject方法返回值的类型决定-->

<bean

id="pfb"class="com.maple.spring.customtype.PersonFactoryBean"/>

6. 简化配置(p和c命名空间)

p和c命名空间是Spring3.0引入的，为了简化书写。

p:属性 property

c：构造函数 constructor

c:parent-ref=”p5”引用其他bean。

      <!-- 使用了p和c命名空间

      要在声明schema时加入

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

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

      -->

      <bean id="p2"class="com.maple.spring.customtype.Person"

           p:name="李四" p:age="23"p:parent-ref="p3"/>

      <bean id="p3"class="com.maple.spring.customtype.Person"

           c:name="王五"/>

7. 代理模式(理解AOP原理的基础)

7.1概念

代理模式的英文叫做Proxy或Surrogate，中文都可译为”代理“，所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式包含抽象主题，代理主题和真实主题。

7.2使用JDK创建代理类

使用JDK的Proxy类创建代理对象时，只能创建实现了某个接口的类的代理对象，没有实现接口的类是不能用JDK的Proxy类来创建代理对象的。

方式1：

/*

           * 创建实现了IHello接口的类的代理对象

           * 参数1：类加载器

           * 参数2：接口的字节码

           * 参数3：回调函数(每次调用代理对象非final修饰方法时都会执行里面的invoke方法)

           */

           IHello hello = (IHello) Proxy.newProxyInstance(TestProxy.class.getClassLoader(),new Class[]{IHello.class},newInvocationHandler() {

@Override

public Object invoke(Objectproxy, Method method, Object[] args)throws Throwable {

System.out.println("执行invoke方法----" +method.getName());

                     returnnull;

                }

          });

           System.out.println(hello);//null

           System.out.println(hello.getClass());//class $Proxy4

            hello.sayHi();//无内容

方式2：

final IHello realObject=new HelloImpl();//真实对象

          //代理对象

          IHellohello = (IHello) Proxy.newProxyInstance(realObject.getClass().getClassLoader(),realObject.getClass().getInterfaces(),newInvocationHandler() {

@Override

public Object invoke(Objectproxy, Method method, Object[] args)throws Throwable {

                     System.out.println("调用"+method.getName() +"前");

                     Objectret = method.invoke(realObject, args);//在真实对象上调用方法，参数不变照传

                     System.out.println("调用"+method.getName() +"后");

                     return ret;//返回执行方法回的对象，为真实对象

                }

          });

          System.out.println(hello);

          hello.sayHi();//这里是真实对象调用方法了，可以输出"大家好！"

      }

方式3：

publicclass TestProxy2implements InvocationHandler{

      private ObjectrealObject;

      /**

       * @param realObject

       * @return代理对象

       */

      public Object createProxyObjectByJdk(ObjectrealObject) {

          this.realObject = realObject;

          return Proxy.newProxyInstance(realObject.getClass().getClassLoader(),realObject.getClass().getInterfaces(),this);

      }

      @Override

      publicObject invoke(Objectproxy, Method method, Object[] args)throws Throwable {

          System.out.println("调用"+method.getName() +"前");

          Objectret = method.invoke(realObject, args);

          System.out.println("调用"+method.getName() +"后");

          returnret;

      }

}

7.3使用CGLIB创建代理类

使用JDK自带的Proxy类不能创建没有实现接口的类的代理对象，这时就要用到第三方类库来创建了。如CGLIB。CGLIB是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。(要加入jar包:cglib-nodep-xx.xx.jar)

使用CGLIB的Enhancer类来创建代理对象。

publicclass TestProxy {

      @Test//创建类的代理对象

      publicvoidtestCglibProxyClass() {

          //真实对象，没有实现任何接口的类

          final HelloImpl2readObject =new HelloImpl2();

          Enhanceren = new Enhancer();

          //设置回调函数

          en.setCallback(newInvocationHandler() {

                

                @Override

public Objectinvoke(Object proxy, Method method, Object[] args)throws Throwable {

returnmethod.invoke(readObject, args);//调用真实对象的方法并返回

                }

          });

          en.setSuperclass(HelloImpl2.class);//设置父类

          HelloImpl2hello2 = (HelloImpl2) en.create();//创建类的代理对象

          hello2.sayHi();

      }

      @Test//创建接口的代理对象

      publicvoidtestCglibProxyInterface() {

          final IHello readObject=new HelloImpl();

          Enhanceren = new Enhancer();

          //设置回调函数

          en.setCallback(newInvocationHandler() {

                @Override

                public Objectinvoke(Object proxy, Method method, Object[] args)throws Throwable {

returnmethod.invoke(readObject, args);//调用真实对象的方法并返回

                }

          });

          en.setSuperclass(IHello.class);//设置父类

          IHellohello = (IHello) en.create();//创建接口的代理对象

          hello.sayHi();

      }

}

 7.4代理总结

spring在运行期创建代理,不需要特殊的编译器。

spring有两种代理方式：

1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。

2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

使用该方式时需要注意:

1.对接口创建代理优于对类创建代理，因为会产生更加松耦合的系统。

对类代理是让遗留系统或无法实现接口的第三方类库同样可以得到通知，这种方式应该是备用方案。

2.标记为final的方法不能够被通知。spring是为目标类产生子类。任何需要被通知的方法都被复写，将通知织入。final方法是不允许重写的。

 

 

xiaojianfengye1
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot 接口多实现的用途--@Autowired 注入map、List spring getBean的首字母大小写问题
silence_lu_的博客
10-28 906
在Springboot中，一般接口是单实现的话，只需要直接注入即可。 但当接口有多个实现的时候就不能直接注入，会报错提示有多个实现类。 有几种方式可以解决： 一.写死，加上 @Qualifier(“XXX”)就好了，用于指定注入那个实现类 @Autowired @Qualifier("studentService") private PersonService...
Spring 学习笔记(二)
duoduomother的专栏
01-08 125
1、PropertyPlaceholderConfigurer实例 在实际的项目应用中，常常将数据库的链接配置信息保存在.properties文件中，将数据库访问驱动保存到spring配置文件中，为自动从属性文件中读取保存的数据库配置信息，使用 PropertyPlaceholderConfigurer 类在spring配置文件中设置与数据源配置相对应的属性文件 <bean id="prope
Spring注解@Component、@Repository、@Service、@Controller区别
08-10 318
@Repository注解：用于标注数据访问组件，即DAO组件 @Service注解：用于标注业务层组件 @Controller注解：用于标注控制层组件（如struts中的action） @Component注解：泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。 事实上这几个注解并没有任何功能上的区别，你可以把这些当做是分类标签，目的是为了让你的代码可读性更强。 在Annotaion
Spring学习笔记（一）Spring框架入门
weixin_72154059的博客
02-06 1520
1、 我们经常挂在口中的Spring指的是（Spring 框架）它是一个开源框架，有着活跃而庞大的社区。这就是它之所以能长久不衰的原因，Spring支持广泛的应用场景，它可以让Java企业级开发应用程序开更简单。2、Spring是由Rod Johnson组织和开发的一个分层的Java SE/EE一站式（full-stack）轻量级开源框架。它最为核心的理念是IoC（控制反转）和AOP（面向切面编程），其中，IoC是Spring的基础，它支撑着Spring对JavaBean的管理功能；
Spring Boot学习笔记（2）
sun_yi_gui的博客
10-26 106
Spring Boot 配置 一、配置文件 -Spring Boot使用一个全局的配置文件，配置文件名是固定的； application.properties application.yml 配置文件的作用：修改SpringBoot自动配置的默认值； SpringBoot在底层都给我们自动配置好 YAML （YAML Ain’t Markup Language） YAML A Markup L...
SPRING学习笔记2
03-19
Spring学习笔记2涵盖了Spring框架的核心概念和重要特性，旨在帮助开发者深入理解并熟练掌握Spring的使用。 1. **依赖注入（Dependency Injection, DI）**：这是Spring最核心的设计原则，它允许对象之间的依赖关系在...
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
Spring Cloud Alibaba学习笔记
03-18
Spring Cloud Alibaba学习笔记 内容简介： 1、微服务介绍 2、微服务环境搭建 3、Nacos Discovery--服务治理 4、Gateway--服务网关 5、Sleuth--链路追踪 6、Rocketmq--消息驱动 7、SMS--短信服务 8、Sentinel--服务...
javaSpring学习笔记
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
spring学习笔记2
06-03
个人心得，希望对你有所帮助
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 228
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
Spring3(代理模式 Spring1案例补充 Aop 面试题)
qq_52897007的博客
07-17 1119
为其他对象提供一种代理以控制对这个对象的访问。
【springboot】中使用--WebMvcConfigurer
2201_75743716的博客
07-19 546
import com/*** 将请求参数字符串转为 DeviceInfo");} }/*** 将请求参数字符串转为 DeviceInfo");} }/*** 将请求参数字符串转为 DeviceInfo");import org/*** 将请求参数字符串转为 DeviceInfo");} }/**
SpringMVC 控制层框架-下
woai3364的博客
07-20 585
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
记录些Spring+题集（4）
安静的软件工程师
07-20 846
记录些Spring+题集（4）
手写简易版Spring IOC容器02【学习】
weixin_44794897的博客
07-19 451
其中applyPropertyValues用于从beanDefinition中读取属性的配置信息然后通过BeanUtil(hutool-all中提供的类)为其赋值@Overridetry {// 创建bean实例Class<?if (null!break;// 设置属性值try {// 从beanDefinition中获取property通过Resource获取文件流。
Spring-使用
weixin_61094678的博客
07-17 292
众所周知，Spring是一个包含了众多工具的IoC容器。既然是容器就必然包含两个最基本的功能：将对象存储到容器中，从容器中将对象取出来故本篇文章 将讲述如何在Spring中，如何创建，存储，获取并使用Bean对象。
Spring MVC入门 --建立连接以及请求
m0_60963435的博客
07-19 474
(1)普通传参(查询字符串)通常用于提交文件,对应的Content-Type为multipart/form-dataform表单,对应Content-Type:application/x-www-form-urlencoded(4)raw可以上传任意格式的文本,如text,json,xml,html简单来说,JSON就是一种数据格式,有自己的格式和语法,使用文本表示一个对象或者数组的信息,因此实际上本质就是字符串.主要负责在不同语言中数据的传递和交换"squadName": "正义联盟",
SpringBoot-LangChain4j核心源码分析
最新发布
Box_clf的博客
07-20 438
如果有对当前的aiService定义添加tool工具, 那么会tool工具调用对应的大模型function calling的api, 这样模型会知道何时才会去调用系统内部的工具类.注解用于导入其他的配置类，使得这些配置类中的bean定义可以被当前配置类所在的Spring容器中识别和管理。循环调用ai模型, 根据模型反馈需要调用的工具链并将结果告诉模型, 最后根据模型的response返回最终的执行结果给用户。 根据实际的配置信息构建对应的aiService的bean对象。
spring 学习笔记
04-10
以下是关于Spring学习的一些笔记： 1. IoC（控制反转）：Spring通过IoC容器管理对象的创建和依赖关系的注入。通过配置文件或注解，将对象的创建和依赖关系的维护交给Spring容器来管理，降低了组件之间的耦合度。 2...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值