0%

SpringBoot使用jsp

  • 需要添加jsp解析器依赖

    1
    2
    3
    4
    5
    <!-- jsp -->
    <dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    </dependency>
  • 配置资源目录

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <!-- build标签中 -->
    <!-- jsp文件资源目录 -->
    <resources>
    <resource>
    <directory>src/main/webapp</directory>
    <targetPath>META-INF/resources</targetPath>
    <includes>
    <include>**/*.*</include>
    </includes>
    </resource>
    </resources>
  • 注册视图解析器,前缀后缀

    1
    2
    3
    4
    5
    spring:
    mvc:
    view:
    prefix: /
    suffix: .jsp

BeanDefinition属性

BeanDefinition是用来描述一个Bean实例的,包括属性值、构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

// 单例
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
// 原型
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
// 设置模式
void setScope(String scope);
String getScope();

// 描述Bean的角色,通过getRole、setRole
// ROLE_APPLICATION表示这个Bean是用户自己定义的
int ROLE_APPLICATION = 0;
// ROLE_SUPPORT表示这个Bean是某些复杂配置的支撑部分
int ROLE_SUPPORT = 1;
// ROLE_INFRASTRUCTURE表示这是Spring内部的Bean
int ROLE_INFRASTRUCTURE = 2;


// Modifiable attributes

// 配置parent名称 <bean parent="">
void setParentName(String parentName);
String getParentName();

// 配置Bean的class全路径 <bean class="">
void setBeanClassName(String beanClassName);
String getBeanClassName();




// 是否懒加载 <bean lazy-init="">
void setLazyInit(boolean lazyInit);
boolean isLazyInit();

// 配置Bean的依赖对象 <dean depends-on="">
void setDependsOn(String... dependsOn);
String[] getDependsOn();

// 配置Bean是否自动装配 <bean autowire-candidate="">
void setAutowireCandidate(boolean autowireCandidate);
boolean isAutowireCandidate();

// 配置Bean是否为首选的Bean <bean primary="">
void setPrimary(boolean primary);
boolean isPrimary();

// 配置FactoryBean的名字 <bean factory-bean="">
void setFactoryBeanName(String factoryBeanName);
String getFactoryBeanName();

// 配置工厂方法 <bean factory-bean="" factory-method="">
void setFactoryMethodName(String factoryMethodName);
String getFactoryMethodName();

// 返回Bean构造方法的参数值
ConstructorArgumentValues getConstructorArgumentValues();

// 获取普通属性的集合
MutablePropertyValues getPropertyValues();


// Read-only attributes

// 是否单例
boolean isSingleton();
// 是否原型
boolean isPrototype();
// 是否抽象
boolean isAbstract();


int getRole();

// 获取Bean的描述
String getDescription();

// 获取Bean的资源描述
String getResourceDescription();

// 如果当前BeanDefinition是一个代理对象,会返回原始的BeanDefinition
BeanDefinition getOriginatingBeanDefinition();

}

子类

AbstractBeanDefinition

AbstractBeanDefinition是一个抽象类,定义了BeanDefinition中对应的get/set方法的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {


// 默认就是单例模式singleton
public static final String SCOPE_DEFAULT = "";


public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;


public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;


public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;


public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;



/**
* Constant that indicates no dependency check at all.
* @see #setDependencyCheck
*/
public static final int DEPENDENCY_CHECK_NONE = 0;

/**
* Constant that indicates dependency checking for object references.
* @see #setDependencyCheck
*/
public static final int DEPENDENCY_CHECK_OBJECTS = 1;

/**
* Constant that indicates dependency checking for "simple" properties.
* @see #setDependencyCheck
* @see org.springframework.beans.BeanUtils#isSimpleProperty
*/
public static final int DEPENDENCY_CHECK_SIMPLE = 2;

/**
* Constant that indicates dependency checking for all properties
* (object references as well as "simple" properties).
* @see #setDependencyCheck
*/
public static final int DEPENDENCY_CHECK_ALL = 3;

/**
* Constant that indicates the container should attempt to infer the
* {@link #setDestroyMethodName destroy method name} for a bean as opposed to
* explicit specification of a method name. The value {@value} is specifically
* designed to include characters otherwise illegal in a method name, ensuring
* no possibility of collisions with legitimately named methods having the same
* name.
* <p>Currently, the method names detected during destroy method inference
* are "close" and "shutdown", if present on the specific bean class.
*/
public static final String INFER_METHOD = "(inferred)";


private volatile Object beanClass;
// bean的作用域,对应bean标签属性scope
private String scope = SCOPE_DEFAULT;
// 是否抽象,对应bean标签属性abstract
private boolean abstractFlag = false;
// 是否延迟加载,对应bean标签属性lazy-init
private boolean lazyInit = false;
// 自动注入模式,对应bean标签属性autowire
private int autowireMode = AUTOWIRE_NO;
// 依赖检查,spring3.0中弃用
private int dependencyCheck = DEPENDENCY_CHECK_NONE;
// 一个bean的实例化依赖于另一个bean的实例化,对应bean标签属性depends-on
private String[] dependsOn;
// 如果该属性设置为false,容器在进行自动装配对象时不会考虑该bean,但是该bean本身还是可以使用自动装配来注入其他bean的,对应bean标签属性autowire-candidate
private boolean autowireCandidate = true;
// 自动装配时出现多个bean的候选时,如果primary设置为true,则作为首选,对应bean标签属性primary
private boolean primary = false;
// 用于记录Qualifier,对应子元素qualifier
private final Map<String, AutowireCandidateQualifier> qualifiers =
new LinkedHashMap<String, AutowireCandidateQualifier>(0);
// 允许访问非公开的构造器和方法,通过程序设置,不在xml中配置
private boolean nonPublicAccessAllowed = true;
// 是否以一种宽松的模式解析构造函数,如果为false,如果spring无法精确地定位某个构造函数的话则抛出异常
private boolean lenientConstructorResolution = true;
// 记录工厂bean对应的id,对应bean标签属性factory-bean
private String factoryBeanName;
// 记录工厂bean中生产bean的方法,对应bean标签属性factory-method
private String factoryMethodName;
// 记录构造函数注入属性,对应bean标签属性contructor-arg
private ConstructorArgumentValues constructorArgumentValues;
// 普通属性集合
private MutablePropertyValues propertyValues;
// 方法重写的持有者,记录lookup-method、replaced-method元素
private MethodOverrides methodOverrides = new MethodOverrides();
// 初始化方法,对应bean标签属性init-method
private String initMethodName;
// 销毁方法,对应bean标签属性destory-method
private String destroyMethodName;
// 是否执行init-method,通过程序设置,不在xml中配置
private boolean enforceInitMethod = true;
// 是否执行destory-method,通过程序设置,不在xml中配置
private boolean enforceDestroyMethod = true;
// 是否是用户定义的而不是应用程序本身定义的,创建AOP时为true,通过程序设置,不在xml中配置
private boolean synthetic = false;
// 定义这个bean的角色,ROLE_APPLICATION:用户 ROLE_SUPPORT:某些复杂配置的一部分 ROLE_INFRASTRUCTURE:完全内部使用,与用户无关
private int role = BeanDefinition.ROLE_APPLICATION;
// bean的描述信息
private String description;
// bean定义的资源
private Resource resource;

}

RootBeanDefinition

对应了一般的元素标签

1
public class RootBeanDefinition extends AbstractBeanDefinition

ChildBeanDefinition

可以让子BeanDefinition定义拥有从父BeanDefinition那里继承配置的能力

1
public class ChildBeanDefinition extends AbstractBeanDefinition

GenericBeanDefinition

可以动态设置父Bean,同时兼具了RootBeanDefinition和ChildBeanDefinition的功能

1
public class GenericBeanDefinition extends AbstractBeanDefinition

AnnotatedBeanDefinition

接口,表示注解类型的BeanDefinition,拥有获取元数据和方法元数据的能力

1
public interface AnnotatedBeanDefinition extends BeanDefinition

AnnotatedGenericBeanDefinition

使用了@Configuration注解的配置类会被解析为AnnotatedGenericBeanDefinition

1
public class AnnotatedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition

通信

在进行通信时,每一个分层中,都会对所发送的数据附加一个首部,包含了该层的必要信息

在应用层进行数据的组装,经过编码之后进行发送,建立TCP连接;TCP将从应用层发来的数据进行加工,在应用层数据的前端附加一个TCP首部,其中包括端口号、目标端口号、序号以及检验和,然后发送给IP;IP将TCP传过来的TCP首部和TCP数据合起来作为自己的数据,并在TCP首部前端加上IP首部,其中包含接收端的IP地址以及发送端的IP地址;数据链路层接收到IP传过来的IP包,在附加上以太网首部,其中包含接收端的MAC地址、发送端的MAC地址、标志以太网类型的以太网数据的协议

然后在进行接收时,进行逆向处理

MAC地址

MAC地址是用于识别数据链路中互连的节点,标识同一个链路中不同计算机的的一种识别码

配置

elasticsearch配置有两种配置方式,一种是静态配置,只能在配置文件中进行配置;一种是动态配置,可以通过_cluster/settings进行设置

网络配置

本地网关配置

本地网关是当所有集群重新启动时存储集群状态和分片数据的模块,属于静态配置

1
2
3
4
5
6
7
8
9
"gateway": {
"recover_after_master_nodes": "0",// 集群中存在多少个主节点才启动恢复过程
"expected_nodes": "-1", // 集群中的预计节点数量
"recover_after_data_nodes": "-1", // 集群中存在多少个数据节点才启动恢复过程
"expected_data_nodes": "-1",// 集群中数据节点预计数量
"recover_after_time": "0ms", // 节点数满足后,等待多长时间开始恢复过程
"expected_master_nodes": "-1",// 集群中主节点预计数量
"recover_after_nodes": "-1" // 集群中存在多少个节点才启动恢复过程
}
阅读全文 »