Spring使用@Autowired注解实现自动装配方式-FinClip官网

Spring使用@Autowired注解实现自动装配方式

网友投稿 909 2022-12-04

Spring使用@Autowired注解实现自动装配方式

目录Spring支持注解配置引入注解依赖启用注解使用@Autowired注解实现自动装配1、IOC容器配置2、实体类使用@Autowired注解注入属性3、测试结果@Autowired注解的使用和注入规则1.使用在变量域上面2.@Autowired注解使用在构造器上面

Spring支持注解配置

引入注解依赖

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

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

xsi:schemaLocation="http://springframework.org/schema/beans

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

http://springframework.org/schema/context

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

启用注解

使用@Autowired注解实现自动装配

1、IOC容器配置

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

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

xsi:schemaLocation="http://springframework.org/schema/beans

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

http://springframework.org/schema/context

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

2、实体类使用@Autowired注解注入属性

package indi.stitch.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class People {

@Autowired

private Cat cat;

@Autowired

private Dog dog;

public Cat getCat() {

return cat;

}

public Dog getDog() {

return dog;

}

@Override

public String toString() {

return "People{" +

"cat=" + cat +

", dog=" + dog +

'}';

}

Cat实体类

package indi.stitch.pojo;

public class Cat {

public void shout() {

System.out.println("miao~");

}

Dog实体类

package indi.stitch.pojo;

public class Dog {

public void shout() {

System.out.println("wang~");

}

使用@Autowired注解支持自动注入后，可以省略实体类的setter方法

3、测试结果

使用java类库中的@Resource注解可以实现相同的效果，@Autowired和@Resource注解的区别是

@Autowired注解默认按byType方式实现，@Resource注解默认按byName方式实现

@Autowired注解在IOC容器中配置了多个相同类型的bean时，需要配合@Qualifier找到唯一bean

@Autowired

@Qualifier("cat")

private Cat cat;

@Resource注解可以配置name和type属性进行bean的注入

@Resource(name = "dog", type = Dog.class)

private Dog dog;

@Resource属性单独使用name属性后，将不会按照byType方式查找bean，@Autowired注解可以使用required属性来决定注入的属性是否允许为空

@Autowired(required = false)

@Qualifier("cat")

private Cat cat;

@Autowired注解的使用和注入规则

作为一个Spring开发者对@Autowired注解必定是非常了解了, 顾名思义自动装配，应该是Spring会自动将我们标记为@Autowired的元素装配好，与其猜测不如看看它的定义：

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface Autowired {

boolean required() default true;

}

很明显这个注解可以用到构造器，变量域，方法，注解类型和方法参数上。文档上这样描述：将一个构造器，变量域，setter方法，config方法标记为被Spring DI 工具自动装配。换句话说，在Spring创建bean的过程中，会为这个bean中标有@Autowired注解的构造器，变量域，方法和方法参数中自动注入我们需要的已经在Spring IOC容器里面的bean，，而无需我们手动完成，并且注入的bean都是单实例，也就是在两个bean中都依赖第三个bean，那么这两个bean中注入的第三个bean会是同一个bean（JVM中指向的地址相同）。

在@Autowired注解里面有一个required属性，该属性默认为true，当为true时，表示去Spring IOC中查找相应的bean，如果找不到，则会报错，如果为false时，表示去Spring IOC中查找相应的bean，如果找不到，则直接忽略，不再进行注入。

@Autowired注解的注入规则：默认按照类型进行注入，如果IOC容器中存在两个及以上的相同类型的bean时，根据bean的名称进行注入，如果没有指定名称的bean，则会报错。

可以使用@Qualifier("wheel")来使用指定id的bean，也可以在注入bean时，添加@Primary注解，优先添加一个bean，其规则如下：

如果指定添加了@Qualifier("wheel")则按照指定的bean id进行添加(优先级最高）,找不到则直接报错。如果没有添加@Qualifier而添加了@Primary注解，则首先添加标注了@Primary注解的bean。当即存在@Qualifier注解也存在@Primary注解注解，则按照@Qualifier指定的bean id注入，找不到直接报错。

很多人java开发者都知道@Autowired注解，但是真正用的好的也不多（反正系统的学习Spring之前我是不知道的），那下面让我们来看一下@Autowired的用法：

1.使用在变量域上面

这个相信大家都已经清楚了，Spring会帮我们注入我们想要的bean，看下面的例子：

package it.cast.circularDependency;

@Component

public class Wheel {

}

@Component

public class Car {

@Autowired

private Wheel wheel2;

public Wheel getWheel() {

return wheel2;

}

public void setWheel(Wheel wheel2) {

this.wheel2 = wheel2;

}

@ComponentScan({"it.cast.circularDependency"})

public class AutowiredConfig {

}

下面进行测试，打印的结果显示可以拿到Wheel类，说明@Autowired注解在IOC容器中只有一个类型的bean时，按照类型进行注入。

@Test

public void AutowiredConfigTest(){

AnnotationConfigApplicationContext context =

new AnnotationConfigApplicationContext(AutowiredConfig.class);

Car bean = context.getBean(Car.class);

System.out.println(bean.getWheel());

}

//打印结果：

// it.cast.circularDependency.Wheel@3eb25e1a

下面看一下当IOC容器中有两个Wheel类型的bean时的情况，改造Wheel类，增加一个属性标识用于记录向Car类中注入的哪个Wheel的bean，在AutowiredConfig配置类中添加一个bean，bean的名称默认为方法名，也就是wheel1。

@Component

public class Wheel {

private int num = 2; //通过包扫描的方式注入的bean的num值为2

public int getNum() {

return num;

}

public void setNum(int num) {

this.num = num;

}

@Component

public class Car {

@Autowired

private Wheel wheel3;//将变量名改成wheel3，IOC容器中Wheel类型的bean的名称只有wheel和wheel1

public Wheel getWheel() {

return wheel3;

}

public void setWheel(Wheel wheel3) {

this.wheel3 = wheel3;

}

@Configuration

@ComponentScan({"it.cast.circularDependency"})

public class AutowiredConfig {

@Bean

public Wheel wheel1(){

Wheel wheel = new Wheel();//通过配置类注入bean的方式num值为0

wheel.setNum(0);

return wheel;

}

这时在Spring IOC中有两个Wheel类型的bean了，Car在注入Wheel类型的bean时，会根据变量名wheel3去找，也就是说会去找类型为Wheel，名称为wheel3的bean，显然是找不到的，也就会报错。

Exception encountered during context initialization - cancelling refresh attempt:

org.springframework.KioNHIwWDTbeans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'car':

Unsatisfied dependency expressed through field 'wheel3';

nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException:

No qualifying bean of type 'it.cast.circularDependency.Wheel' available:

expected single matching bean but found 2: wheel,wheel1

org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'car': Unsatisfied dependency expressed through field 'wheel3';

nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException:

No qualifying bean of type 'it.cast.circularDependency.Wheel' available:

expected single matching bean but found 2: wheel,wheel1

上面为报错的日志打印，大致意思说的在创建名称为car的bean时，不能为变量域wheel3完成属性注入，因为找到了两个bean，分别是wheel和wheel1。

如果我们把Car中的wheel3换成wheel就可以完成注入了，而且注入的bean是通过包扫描注入IOC的bean：

@Component

public class Wheel {

private int num = 2; //通过包扫描的方式注入的bean的num值为2

public int getNum() {

return num;

}

public void setNum(int num) {

this.num = num;

}

@Component

public class Car {

@Autowired

private Wheel wheel;//将变量名改成wheel1，IOC容器中Wheel类型的bean的名称只有wheel和wheel1

public Wheel getWheel() {

return wheel;

}

public void setWheel(Wheel wheel3) {

this.wheel = wheel;

}

@Configuration

@ComponentScan({"it.cast.circularDependency"})

public class AutowiredConfig {

@Bean

public Wheel wheel1(){

Wheel wheel = new Wheel();//通过配置类注入bean的方式num值为0

wheel.setNum(0);

return wheel;

}

在测试类中打印num值看看注入的是哪个bean：

@Test

public void AutowiredConfigTest(){

AnnotationConfigApplicationContext context =

new AnnotationConfigApplicationContext(AutowiredConfig.class);

Car bean = context.getBean(Car.class);

System.out.println(bean.getWheel().getNum());

}

//打印结果：

// 2

那么就验证了上面所说的注入规则：默认按照类型进行注入，如果IOC容器中存在两个及以上的相同类型的bean时，根据bean的名称进行注入，如果没有指定名称的bean，则会报错。

@Autowired注解使用在变量域中还可以解决循环依赖的问题，循环依赖问题就是A对象中注入了B对象，B对象中注入了A对象，循环依赖在面试Spring这一块的知识应该经常会被问题，关于循环依赖的问题，在后面的博客中会更新。

2.@Autowired注解使用在构造器上面

@Autowired使用在构造器上面有几条需要特别注意的点：

1.@Autowired标注在构造器上面不能解决循环依赖构造的问题

2.@Autowired可以标注在同一个类的多个构造器上面，但是required属性必须都为false，当required有一个为true时，不允许其他构造器标有@Autowired注解，即使required属性为false也不行。

@Component

public class A {

private B b;

private C c;

@Autowired

public A(B b, C c) {

System.out.println("b=" + b + ", c=" + c);

this.b = b;

this.c = c;

}

@Component

public class B {

}

@Component

public class C {

}

//打印结果：

// b=it.cast.circularDependency.B@68e965f5, c=it.cast.circularDependency.C@6f27a732

@Autowired标注在构造器上面，在B创建的过程中，会去Spring IOC中拿到需要的注入的bean，完成B的创建，其实在只有一个构造器的情况中，@Autowired可以不加，因为Spring内部有自动推断构造器的能力，这个如果想了解自动推断构造器的同学可以自行百度（实在是太难了，一脸蒙蔽）。

下面看一个构造器循坏依赖的案例：

@Component

public class C {

private B b;

public C(B b) {

this.b = b;

}

@Component

public class B {

private C c;

public B(C c) {

this.c = c;

}

Spring目前不能解决构造器的循环依赖，所以在项目中使用的时候要格外注意一下，错误日志：

org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'a' defined in file

[E:\IdeaProjects\javaBasis\spring\target\classes\it\cast\circularDependency\A.class]:

Unsatisfied dependency expressed through constructor parameter 0;

nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'b' defined in file

[E:\IdeaProjects\javaBasis\spring\target\classes\it\cast\circularDependency\B.class]:

Unsatisfied dependency expressed through constructor parameter 0;

nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'c' defined in file

[E:\IdeaProjects\javaBasis\spring\target\classes\it\cast\circularDependency\C.class]:

Unsatisfied dependency expressed through constructor parameter 0;

nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException:

Error creating bean with name 'b':

Requested bean is currently in creation: Is there an unresolvable circular reference?

下面看一下关于多个@Autowired标注的构造器的案例：

@Component

public class A {

private B b;

private C c;

@Autowired(required = false)

public A(B b) {

this.b = b;

}

@Autowired

public A(B b, C c) {

System.out.println("b=" + b + ", c=" + c);

this.b = b;

this.c = c;

}

@Component

public class B {

}

@Component

public class C {

}

上面已经说到，如果@Autowired注解的属性required为true时，不允许再出现其他构造器上面标有@Autowired注解（@Autowired注解的required默认为true，所以上面的会报错），错误日志为：

org.springframework.beans.factory.BeanCreationException:

Error creating bean with name 'a': Invalid autowire-marked constructors:

[public it.cast.circularDependency.A(it.cast.circularDependency.B)].

Found constructor with 'required' Autowired annotation:

public it.cast.circularDependency.A(it.cast.circularDependency.B,it.cast.circularDependency.C)

使用下面的写法就不会出现错误了，Spring支持多个构造器有@Autowired注解，但是required属性必须都是false

@Component

public class A {

private B b;

private C c;

@Autowired(required = false)

public A(B b) {

this.b = b;

}

@Autowired(required = false)

public A(B b, C c) {

System.out.println("b=" + b + ", c=" + c);

this.b = b;

this.c = c;

}

@Component

public class B {

}

@Component

public class C {

}

关于@Autowired标注在方法上就不多介绍，会首先拿到方法的参数列表，然后根据上面所说的注入规则去Spring IOC中找相应的bean。

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

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

xsi:schemaLocation="http://springframework.org/schema/beans

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

http://springframework.org/schema/context

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

启用注解

使用@Autowired注解实现自动装配

1、IOC容器配置

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

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

xsi:schemaLocation="http://springframework.org/schema/beans

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

http://springframework.org/schema/context

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

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

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

xsi:schemaLocation="http://springframework.org/schema/beans

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

http://springframework.org/schema/context

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

2、实体类使用@Autowired注解注入属性

package indi.stitch.pojo;

import org.springframework.beans.factory.annotation.Autowired;

public class People {

@Autowired

private Cat cat;

@Autowired

private Dog dog;

public Cat getCat() {

return cat;

}

public Dog getDog() {

return dog;

}

@Override

public String toString() {

return "People{" +

"cat=" + cat +

", dog=" + dog +

'}';

}

Cat实体类

package indi.stitch.pojo;

public class Cat {

public void shout() {

System.out.println("miao~");

}

Dog实体类

package indi.stitch.pojo;

public class Dog {

public void shout() {

System.out.println("wang~");

}

使用@Autowired注解支持自动注入后，可以省略实体类的setter方法

3、测试结果

使用java类库中的@Resource注解可以实现相同的效果，@Autowired和@Resource注解的区别是

@Autowired注解默认按byType方式实现，@Resource注解默认按byName方式实现

@Autowired注解在IOC容器中配置了多个相同类型的bean时，需要配合@Qualifier找到唯一bean

@Autowired

@Qualifier("cat")

private Cat cat;

@Resource注解可以配置name和type属性进行bean的注入

@Resource(name = "dog", type = Dog.class)

private Dog dog;

@Resource属性单独使用name属性后，将不会按照byType方式查找bean，@Autowired注解可以使用required属性来决定注入的属性是否允许为空

@Autowired(required = false)

@Qualifier("cat")

private Cat cat;

@Autowired注解的使用和注入规则

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface Autowired {

boolean required() default true;

}

可以使用@Qualifier("wheel")来使用指定id的bean，也可以在注入bean时，添加@Primary注解，优先添加一个bean，其规则如下：

很多人java开发者都知道@Autowired注解，但是真正用的好的也不多（反正系统的学习Spring之前我是不知道的），那下面让我们来看一下@Autowired的用法：

1.使用在变量域上面

这个相信大家都已经清楚了，Spring会帮我们注入我们想要的bean，看下面的例子：

package it.cast.circularDependency;

@Component

public class Wheel {

}

@Component

public class Car {

@Autowired

private Wheel wheel2;

public Wheel getWheel() {

return wheel2;

}

public void setWheel(Wheel wheel2) {

this.wheel2 = wheel2;

}

@ComponentScan({"it.cast.circularDependency"})

public class AutowiredConfig {

}

下面进行测试，打印的结果显示可以拿到Wheel类，说明@Autowired注解在IOC容器中只有一个类型的bean时，按照类型进行注入。

@Test

public void AutowiredConfigTest(){

AnnotationConfigApplicationContext context =

new AnnotationConfigApplicationContext(AutowiredConfig.class);

Car bean = context.getBean(Car.class);

System.out.println(bean.getWheel());

}

//打印结果：

// it.cast.circularDependency.Wheel@3eb25e1a

@Component

public class Wheel {

private int num = 2; //通过包扫描的方式注入的bean的num值为2

public int getNum() {

return num;

}

public void setNum(int num) {

this.num = num;

}

@Component

public class Car {

@Autowired

private Wheel wheel3;//将变量名改成wheel3，IOC容器中Wheel类型的bean的名称只有wheel和wheel1

public Wheel getWheel() {

return wheel3;

}

public void setWheel(Wheel wheel3) {

this.wheel3 = wheel3;

}

@Configuration

@ComponentScan({"it.cast.circularDependency"})

public class AutowiredConfig {

@Bean

public Wheel wheel1(){

Wheel wheel = new Wheel();//通过配置类注入bean的方式num值为0

wheel.setNum(0);

return wheel;

}

Exception encountered during context initialization - cancelling refresh attempt:

org.springframework.KioNHIwWDTbeans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'car':

Unsatisfied dependency expressed through field 'wheel3';

nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException:

No qualifying bean of type 'it.cast.circularDependency.Wheel' available:

expected single matching bean but found 2: wheel,wheel1

org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'car': Unsatisfied dependency expressed through field 'wheel3';

nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException:

No qualifying bean of type 'it.cast.circularDependency.Wheel' available:

expected single matching bean but found 2: wheel,wheel1

上面为报错的日志打印，大致意思说的在创建名称为car的bean时，不能为变量域wheel3完成属性注入，因为找到了两个bean，分别是wheel和wheel1。

如果我们把Car中的wheel3换成wheel就可以完成注入了，而且注入的bean是通过包扫描注入IOC的bean：

@Component

public class Wheel {

private int num = 2; //通过包扫描的方式注入的bean的num值为2

public int getNum() {

return num;

}

public void setNum(int num) {

this.num = num;

}

@Component

public class Car {

@Autowired

private Wheel wheel;//将变量名改成wheel1，IOC容器中Wheel类型的bean的名称只有wheel和wheel1

public Wheel getWheel() {

return wheel;

}

public void setWheel(Wheel wheel3) {

this.wheel = wheel;

}

@Configuration

@ComponentScan({"it.cast.circularDependency"})

public class AutowiredConfig {

@Bean

public Wheel wheel1(){

Wheel wheel = new Wheel();//通过配置类注入bean的方式num值为0

wheel.setNum(0);

return wheel;

}

在测试类中打印num值看看注入的是哪个bean：

@Test

public void AutowiredConfigTest(){

AnnotationConfigApplicationContext context =

new AnnotationConfigApplicationContext(AutowiredConfig.class);

Car bean = context.getBean(Car.class);

System.out.println(bean.getWheel().getNum());

}

//打印结果：

// 2

2.@Autowired注解使用在构造器上面

@Autowired使用在构造器上面有几条需要特别注意的点：

1.@Autowired标注在构造器上面不能解决循环依赖构造的问题

@Component

public class A {

private B b;

private C c;

@Autowired

public A(B b, C c) {

System.out.println("b=" + b + ", c=" + c);

this.b = b;

this.c = c;

}

@Component

public class B {

}

@Component

public class C {

}

//打印结果：

// b=it.cast.circularDependency.B@68e965f5, c=it.cast.circularDependency.C@6f27a732

下面看一个构造器循坏依赖的案例：

@Component

public class C {

private B b;

public C(B b) {

this.b = b;

}

@Component

public class B {

private C c;

public B(C c) {

this.c = c;

}

Spring目前不能解决构造器的循环依赖，所以在项目中使用的时候要格外注意一下，错误日志：

org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'a' defined in file

[E:\IdeaProjects\javaBasis\spring\target\classes\it\cast\circularDependency\A.class]:

Unsatisfied dependency expressed through constructor parameter 0;

nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'b' defined in file

[E:\IdeaProjects\javaBasis\spring\target\classes\it\cast\circularDependency\B.class]:

Unsatisfied dependency expressed through constructor parameter 0;

nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name 'c' defined in file

[E:\IdeaProjects\javaBasis\spring\target\classes\it\cast\circularDependency\C.class]:

Unsatisfied dependency expressed through constructor parameter 0;

nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException:

Error creating bean with name 'b':

Requested bean is currently in creation: Is there an unresolvable circular reference?

下面看一下关于多个@Autowired标注的构造器的案例：

@Component

public class A {

private B b;

private C c;

@Autowired(required = false)

public A(B b) {

this.b = b;

}

@Autowired

public A(B b, C c) {

System.out.println("b=" + b + ", c=" + c);

this.b = b;

this.c = c;

}

@Component

public class B {

}

@Component

public class C {

}

org.springframework.beans.factory.BeanCreationException:

Error creating bean with name 'a': Invalid autowire-marked constructors:

[public it.cast.circularDependency.A(it.cast.circularDependency.B)].

Found constructor with 'required' Autowired annotation:

public it.cast.circularDependency.A(it.cast.circularDependency.B,it.cast.circularDependency.C)

使用下面的写法就不会出现错误了，Spring支持多个构造器有@Autowired注解，但是required属性必须都是false

@Component

public class A {

private B b;

private C c;

@Autowired(required = false)

public A(B b) {

this.b = b;

}

@Autowired(required = false)

public A(B b, C c) {

System.out.println("b=" + b + ", c=" + c);

this.b = b;

this.c = c;

}

@Component

public class B {

}

@Component

public class C {

}

关于@Autowired标注在方法上就不多介绍，会首先拿到方法的参数列表，然后根据上面所说的注入规则去Spring IOC中找相应的bean。

微前端架构如何改变企业的开发模式与效率提升

909 2022-12-04

Spring使用@Autowired注解实现自动装配方式

洞察管理小程序实例的关键在于实现跨平台能力与数据安全，如何利用FinClip助力企业在数字化转型中既合规又高效？

微前端架构如何改变企业的开发模式与效率提升

轻量级前端框架助力开发者提升项目效率与性能

最近发表

更多内容

小程序SDK

Finclip技术文档

小程序开发

小程序容器

小程序框架

Finclip小程序平台

Finclip用户投稿

车联网

推荐文章

小程序SDK是什么意思？小程序sdk和插件有什么区别？

小程序支付功能怎么实现？

企业app开发流程是什么？

app运营模式有哪些？

小程序多端引流怎么做？

小程序生态分析的机会和威胁

Flutter入门这一篇效率文章就够了

原生与跨平台解决方案分析,跨平台软件开发技术方案

热更新技术：让软件更新变得更加轻松快速

解决方案

银行解决方案

证券解决方案

互联网解决方案

政企OA解决方案

科技解决方案

loT解决方案

信任解决方案

热评文章

AppCan:基于混合模式的移动应用开发,移动混合模

Hybrid App混合模式开发的了解

小程序容器技术助力券商数字营销突围，小程序容器化的意

用mpvue开发微信小程序基础知识（vue.js开发

小程序多端框架全面测评对比，强烈推荐！

券商app架构 - 解析券商应用程序的构建与设计