【零散知识点总结3】

木林森屿城

已于 2022-05-25 11:04:56 修改

阅读量930

点赞数

分类专栏： java Linux 微服务文章标签： java

于 2022-03-13 16:57:13 首次发布

本文链接：https://blog.csdn.net/weixin_44543307/article/details/123380931

版权

大部分知识点来源于该博主——骆昊
知识点来源于网络，知道的可以在评论区贴上来源喔

《零散知识点总结1》
该文章涉及：Dubbo、HTTP和HTTPS、Mybatis、Hibernate、 Zookeeper、Kafka、Elasticsearch、Redis

《零散知识点总结2》
该文章涉及：MySQL、Java并发编程、Java IO 和 NIO、JUnit单元测试

《零散知识点总结3》
该文章涉及：Java Web、Spring、SpringMVC、Springboot、Springcloud、微服务

《零散知识点总结4》
该文章涉及：JVM和GC、Linux、Git、RabbitMQ

《零散知识点总结5》
该文章涉及：多线程、反射、对象拷贝、异常、容器

Java Web

Java Web学习：
	Tomcat
	Http
	Maven
	Servlet
	Session、 Cookie
	JSP
	三层架构：
		表示层（UI）主要对用户的请求接受，以及数据的返回，为客户端提供应用程序的访问
		业务逻辑层（BLL）主要负责对数据层的操作。也就是说把一些数据层的操作进行组合。
		数据访问层（DAL）主要看数据层里面有没有包含逻辑处理，实际上它的各个函数主要完成各个对数据文件的操作。而不必管其他操作
	JSTL、EL表达式
	过滤器 filter（后面会学spring自带有【filter】，自己编写拦截器【interceptor】）
	监听器
	文件上传
	邮件发送
	【扩展】富文本编辑器

JSP 和 servlet 有什么区别？

JSP 是 servlet 技术的扩展，本质上就是 servlet 的简易方式。

servlet 和 JSP 最主要的不同点在于，servlet 的应用逻辑是在 Java 文件中，并且完全从表示层中的 html 里分离开来，而 JSP 的情况是 Java 和 html 可以组合成一个扩展名为 JSP 的文件。

JSP 侧重于视图，servlet 主要用于控制逻辑。

JSP 有哪些内置对象？作用分别是什么？

JSP 有 9 大内置对象：

request：封装客户端的请求，其中包含来自 get 或 post 请求的参数；
response：封装服务器对客户端的响应；
pageContext：通过该对象可以获取其他对象；
session：封装用户会话的对象；
application：封装服务器运行环境的对象；
out：输出服务器响应的输出流对象；
config：Web 应用的配置对象；
page：JSP 页面本身（相当于 Java 程序中的 this）；
exception：封装页面抛出异常的对象。

说一下 JSP 的 4 种作用域？

page：代表与一个页面相关的对象和属性。
request：代表与客户端发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件；需要在页面显示的临时数据可以置于此作用域。
session：代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的 session 中。
application：代表与整个 Web 应用程序相关的对象和属性，它实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域。

session 和 cookie 有什么区别？

存储位置不同：session 存储在服务器端；cookie 存储在浏览器端。
安全性不同：cookie 安全性一般，在浏览器存储，可以被伪造和修改。
容量和个数限制：cookie 有容量限制，每个站点下的 cookie 也有个数限制。
存储的多样性：session 可以存储在 Redis 中、数据库中、应用程序中；而 cookie 只能存储在浏览器中。

说一下 session 的工作原理？

session 的工作原理是客户端登录完成之后，服务器会创建对应的 session，session 创建完之后，会把 session 的 id 发送给客户端，客户端再存储到浏览器中。这样客户端每次访问服务器时，都会带着 sessionid，服务器拿到 sessionid 之后，在内存找到与之对应的 session 这样就可以正常工作了。

如果客户端禁止 cookie 能实现 session 还能用吗？

可以用，session 只是依赖 cookie 存储 sessionid，如果 cookie 被禁用了，可以使用 url 中添加 sessionid 的方式保证 session 能正常使用。

spring mvc 和 struts 的区别是什么？

拦截级别：struts2 是类级别的拦截；spring mvc 是方法级别的拦截。
数据独立性：spring mvc 的方法之间基本上独立的，独享 request 和 response 数据，请求数据通过参数获取，处理结果通过 ModelMap 交回给框架，方法之间不共享变量；而 struts2 虽然方法之间也是独立的，但其所有 action 变量是共享的，这不会影响程序运行，却给我们编码和读程序时带来了一定的麻烦。
拦截机制：struts2 有以自己的 interceptor 机制，spring mvc 用的是独立的 aop 方式，这样导致struts2 的配置文件量比 spring mvc 大。
对 ajax 的支持：spring mvc 集成了ajax，所有 ajax 使用很方便，只需要一个注解 @ResponseBody 就可以实现了；而 struts2 一般需要安装插件或者自己写代码才行。

如何避免 SQL 注入？

使用预处理 PreparedStatement 【java.sql包中的接口，预备声明】。
使用正则表达式过滤掉字符中的特殊字符。

什么是 XSS 攻击，如何避免？

XSS 攻击：即跨站脚本攻击，它是 Web 程序中常见的漏洞。原理是攻击者往 Web 页面里插入恶意的脚本代码（css 代码、Javascript 代码等），当用户浏览该页面时，嵌入其中的脚本代码会被执行，从而达到恶意攻击用户的目的，如盗取用户 cookie、破坏页面结构、重定向到其他网站等。
预防 XSS 的核心是必须对输入的数据做过滤处理。

什么是 CSRF 攻击，如何避免？

CSRF：Cross-Site Request Forgery（中文：跨站请求伪造），可以理解为攻击者盗用了你的身份，以你的名义发送恶意请求，比如：以你名义发送邮件、发消息、购买商品，虚拟货币转账等。

防御手段：

验证请求来源地址；
关键操作添加验证码；
在请求地址添加 token （令牌）并验证。

Spring

 Spring学习：
 	IOC理论推导
 	spring概述
 	IOC-Beans.xml
 	DI-Set/cp【重点】  DI(Dependency Injection)：依赖注入
 	代理模式（静态、动态）【重点】
 	AOP
 	注解开发 spring
 	JavaConfig【半重点】
 	整合mybatis：事务【重点】
	声明式事务

Spring官网
 Spring参考文档

spring组成
在这里插入图片描述

Spring Framework 中有多少个模块，它们分别是什么？

在这里插入图片描述
Spring优点

Spring 是一个开源免费的容器（框架）
Spring是一个轻量级的框架 , 非侵入式的（导包就可以用不会影响你整个项目）
控制反转 IoC （inversion of control）, 面向切面 Aop（Aspect Oriented Programming）
对事物的支持 , 对框架的支持

使用 Spring 框架的好处是什么？

轻量级：Spring 是轻量的，基本的版本大约 2MB。
控制反转（IOC）：Spring 通过控制反转实现了松散耦合，对象们给出它们的依赖，而不是创建或查找依赖的对象们。
面向切面的编程(AOP)：Spring 支持面向切面的编程，并且把应用业务逻辑和系统服务分开。
容器：Spring 包含并管理应用中对象的生命周期和配置。
MVC 框架：Spring 的 WEB 框架是个精心设计的框架，是 Web 框架的一个很好的替代品。
事务管理：Spring 提供一个持续的事务管理接口，可以扩展到上至本地事务下至全局事务（JTA）。
异常处理：Spring 提供方便的API把具体技术相关的异常（比如由JDBC，Hibernate or JDO 抛出的）转化为一致的 unchecked 异常。

总结一句话：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。
在这里插入图片描述

AOP、IOC

AOP：aop 是面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。
```
  简单来说就是统一处理某一“切面”（类）的问题的编程思想，比如统一处理日志、异常等。
```

IOC：ioc：Inversionof Control（中文：控制反转）是 spring 的核心，对于 spring 框架来说，就是由 spring 来负责控制对象的生命周期和对象间的关系。

  简单来说，控制指的是当前对象对内部成员的控制权；控制反转指的是，这种控制权不由当前对象管理了，由其他（类,第三方容器）来管理

解释AOP模块
AOP（Aspect-Oriented Programming）指一种程序设计范型，该范型以一种称为切面（aspect）的语言构造为基础，切面是一种新的模块化机制，用来描述分散在对象、类或方法中的横切关注点（crosscutting concern）。

Spring的IOC有三种注入方式：构造器注入、setter方法注入、根据注解注入

构造器注入
原理 : 为目标对象提供一个构造方法，在构造方法中添加一个依赖对象对应的参数。ioc容器解析时，实例化目标对象时会自动调用构造方法，ioc只需要为构造器中的参数进行赋值；将ioc实例化的依赖对象作为构造器的参数传入。

【构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖】

```kotlin
package com.jpeony.spring.setter;
import com.jpeony.spring.common.HelloServiceImpl;

public class HelloWord {
    private HelloService helloService;
    // 构造方法注入
    public HelloWord (HelloService helloService) {
        this.helloService = helloService;
    }
}
```
`applicationContext.xml`：

```kotlin
<?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声明:
	         该bean类似于javaConfig中的@Bean注解;
	         用于创建bean的类通过class属性来指定，并且需要使用全限定的类名。
	         通过id指定bean的ID。如果不显示指定，默认使用class的全限定名进行命名。
	         eg:
	         com.jpeony.spring.common.HelloServiceImpl#0，其#0是一个计数器的形式，
	         用来区分相同类型的其他bean。
	         使用自动化命名很方便，但是没有多少实际用处，还是建议自己给bean显示设定ID。
	-->
	<bean id="helloService" class="com.jpeony.spring.common.HelloServiceImpl"/>
	<!-- 构造方法注入bean -->
	<bean id="HelloWord" class="com.jpeony.spring.setter.HelloWord">
		<constructor-arg>
			<ref bean-"helloService"/>
		<constructor-arg/>
	</bean>
</beans>
```

setter方法注入
原理 : 在目标对象中，定义需要注入的依赖对象对应的属性和setter方法；“让ioc容器调用该setter方法”，将ioc容器实例化的依赖对象通过setter注入给目标对象，封装在目标对象的属性中。
【Setter方法注入： Setter方法注入是容器通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。】

package com.jpeony.spring.setter;

import com.jpeony.spring.common.HelloServiceImpl;

public class HelloWord {
     
	private HelloService helloService;
    // setter方式注入Bean
    public void setHelloService(HelloService helloService) {
     
        this.helloService = helloService;
    }
    @Override
    public void selfIntroduction() {
     
        // 向大家打招呼
        helloService.sayHello("大家好!");
    }
}

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-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--
	Bean声明:
	         该bean类似于javaConfig中的@Bean注解;
	         用于创建bean的类通过class属性来指定，并且需要使用全限定的类名。
	         通过id指定bean的ID。如果不显示指定，默认使用class的全限定名进行命名。
	         eg:
	         com.jpeony.spring.common.HelloServiceImpl#0，其#0是一个计数器的形式，
	         用来区分相同类型的其他bean。
	         使用自动化命名很方便，但是没有多少实际用处，还是建议自己给bean显示设定ID。
	-->
	<bean id="helloService" class="com.jpeony.spring.common.HelloServiceImpl"/>
	<!-- setter注入bean -->
	<bean id="HelloWord" class="com.jpeony.spring.setter.HelloWord">
		<property name="helloService" ref="helloService"/>
	</bean>
</beans>

注解注入
注解方式实现IOC注入，主要涉及以下几个注解

 @Configuration：添加该注解的类被视为上下文，里面带有@Bean注解的都将被注入到IOC容器
 @ComponentScan：扫描注定包下的所有带@Component的类，注入到IOC容器
 @Bean：添加该注解的方法将返回一个实例，并被注入到IOC容器
 @Component：添加该注解的方法自动被注入到IOC容器，需要被@ComponentScan扫描到
 @Scope：指定实例的作用域
 @PostConstruct：添加该注解的方法在实例初始化的时候被执行
 @PreDestory：添加该注解的方法在实例销毁的时候被执行

案例：
第一步：@Configuration配置一个上下文环境，并在里面使用@Bean注解返回需要注入的对象，指定beanId

@Configuration
public class BeanConfiguration {
   

    //将一个bean交由spring创建并管理
    @Bean(value = "bean1")
    public Bean1 getBean1() {
   
        return new Bean1();
    }
}

第二步：根据beanId获取需要的实例对象

public class IoCAnnotationTest {
   

    @Test
    public void test() {
   
        //获取Spring上下文
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(BeanConfiguration.class);
        //获取bean
//        Bean1 bean1 = (Bean1) context.getBean("getBean1");//beanId默认为方法名
        Bean1 bean1 = (Bean1) context.getBean("bean1");//通过@Bean value属性设置beanId
        System.out.println(bean1);
    }
}

如果有很多bean要注入，那么要写很多@Bean注解吗，这里有更方便的写法

//创建一个class配置文件
@Configuration
//扫描指定包下的所有带@Component的bean，交由Spring管理
@ComponentScan(value = "com.kingja.iocannotation.bean")
public class BeanScanConfiguration {
   
	......
}

在需要注入的类上添加@Component注解，并设置beanId

//通过value设置beanId
@Component(value = "bean2")
//默认beanId是类名(首字母小写bean2)
public class Bean2 {
   

}

IOC的作用域

实际需求中，我们可能需要每次返回的对象是同一个，也可能每次创建不同的实例对象，也可能根据不同的场景，比如不同请求，不同会话等返回不同实例，这就涉及到Bean的作用域。

Spring支持的几种bean的作用域？

Spring容器中的bean可以分为5个范围：

singleton：（默认）单例模式，创建的实例是同一个，单例的模式由BeanFactory自身来维护。
prototype：每次创建不同的实例
request：每次请求创建不同的实例，在请求完成以后，bean会失效并被垃圾回收器回收
session：每个会话周期内创建同一个实例，与request范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效
global-session：全局作用域，global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

application：服务器运行周期内创建内一个实例
websocket：每次websocket连接创建同一个实例

《Spring–IOC注解方式注入》

基础问题（什么是 Spring Framework？不同版本的 Spring Framework 有哪些主要功能？）

什么是 Spring Framework？

Spring 是一个开源应用框架，旨在降低应用程序开发的复杂度。它是轻量级、松散耦合的。它具有分层体系结构，允许用户选择组件，同时还为 J2EE 应用程序开发提供了一个有凝聚力的框架。它可以集成其他框架，如Structs、Hibernate、EJB 等，所以又称为框架的框架。

不同版本的 Spring Framework 有哪些主要功能？

version	feature
Spring 2.5	发布于 2007 年。这是第一个支持注解的版本。
Spring 3.0	发布于 2009 年。它完全利用了 Java5 中的改进，并为 JEE6 提供了支持。
Spring 4.0	发布于 2013 年。这是第一个完全支持 JAVA8 的版本。
Spring 5.0	推荐1：5.0各模块功能介绍；推荐2：5.0 的一些特性

列举 Spring Framework 的优点，有哪些不同的功能？

由于 Spring Frameworks 的分层架构，用户可以自由选择自己需要的组件。
Spring Framework 支持 POJO(Plain Old Java Object) 编程，从而具备持续集成和可测试性。由于依赖注入和控制反转，JDBC 得以简化。它是开源免费的。

Spring Framework 有哪些不同的功能？

轻量级 - Spring 在代码量和透明度方面都很轻便。
IOC - 控制反转
AOP - 面向切面编程可以将应用业务逻辑和系统服务分离，以实现高内聚。
容器 - Spring 负责创建和管理对象（Bean）的生命周期和配置。
MVC - 对 web 应用提供了高度可配置性，其他框架的集成也十分方便。
事务管理 - 提供了用于事务管理的通用抽象层。Spring 的事务支持也可用于容器较少的环境。
JDBC 异常 - Spring的 JDBC 抽象层提供了一个异常层次结构，简化了错误处理策略。

Spring上下文，什么是 Spring 配置文件？ Spring 应用程序有哪些不同组件？

ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");

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-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- services -->
    <bean id="petStore" class="org.springframework.samples.jpetstore.services.PetStoreServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="itemDao" ref="itemDao"/>
        <!-- additional collaborators and configuration for this bean go here -->
    </bean>
    <!-- more bean definitions for services go here -->
</beans>

核心容器（应用上下文) 模块
这是基本的 Spring 模块，提供 spring 框架的基础功能，BeanFactory 是任何以 spring 为基础的应用的核心。Spring 框架建立在此模块之上，它使 Spring 成为一个容器。

什么是 Spring 配置文件？

Spring 配置文件是 XML 文件。该文件主要包含类信息。它描述了这些类是如何配置以及相互引入的。但是，XML 配置文件冗长且更加干净。如果没有正确规划和编写，那么在大项目中管理变得非常困难。

Spring 应用程序有哪些不同组件？

Spring 应用一般有以下组件：

接口 - 定义功能。
Bean 类 - 它包含属性，setter 和 getter 方法，函数等。
Spring 面向切面编程（AOP） - 提供面向切面编程的功能。
Bean 配置文件 - 包含类的信息以及如何配置它们。
用户程序 - 它使用接

使用 Spring 有哪些方式？

使用 Spring 有以下方式：

作为一个成熟的 Spring Web 应用程序。
作为第三方 Web 框架，使用 Spring Frameworks 中间层。
用于远程使用。
作为企业级 Java Bean，它可以包装现有的 POJO（Plain Old Java Objects）。

BeanFactory – BeanFactory 实现举例。

Bean 工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从正真的应用代码中分离。最常用的 BeanFactory 实现是 XmlBeanFactory 类

XMLBeanFactory

最常用的就是 org.springframework.beans.factory.xml.XmlBeanFactory ，它根据 XML 文件中的定义加载 beans。该容器从 XML 文件读取配置元数据并用它去创建一个完全配置的系统或应用。

解释 AOP 模块

AOP 模块用于发给我们的 Spring 应用做面向切面的开发，很多支持由 AOP 联盟提供，这样就确保了 Spring 和其他 AOP 框架的共通性。这个模块将元数据编程引入 Spring。

解释 JDBC 抽象和 DAO 模块。

通过使用 JDBC 抽象和 DAO 模块，保证数据库代码的简洁，并能避免数据库资源错误关闭导致的问题，它在各种不同的数据库的错误信息之上，提供了一个统一的异常访问层。它还利用 Spring 的 AOP 模块给 Spring 应用中的对象提供事务管理服务。

解释对象/关系映射集成模块。

Spring 通过提供 ORM （对象关系映射）模块，支持我们在直接 JDBC 之上使用一个对象/关系映射(ORM)工具，Spring 支持集成主流的 ORM 框架，如 Hiberate,JDO 和 iBatis
SQL Maps。Spring 的事务管理同样支持以上所有 ORM 框架及 JDBC。

解释 WEB 模块。

Spring 的 WEB 模块是构建在 application context 模块基础之上，提供一个适合 web 应用的上下文。这个模块也包括支持多种面向 web 的任务，如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业务对象。它也有对 Jakarta Struts 的支持。

Spring 配置文件

Spring 配置文件是个 XML 文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用。

ApplicationContext 通常的实现是什么?

FileSystemXmlApplicationContext ：此容器从一个 XML 文件中加载 beans 的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。
ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载 beans 的定义，这里，你需要正确设置 classpath 因为这个容器将在 classpath里找 bean 配置。
WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个 WEB 应用的所有 bean。

一个 Spring 的应用看起来像什么？

一个定义了一些功能的接口。这实现包括属性，它的 Setter ， getter 方法和函数等。 Spring AOP。Spring 的 XML 配置文件。
使用以上功能的客户端程序

IoC（控制反转）

控制反转（Inversion of Control，缩写为IoC）是一种设计思想，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。

其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），DI是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。