本篇文章用来记录一些自己学习的资料和网上比较好的一些java新手学习资料

http://www.manongjc.com/detail/17-hiztriaubzqzxqu.html
https://github.com/JoyChou93/java-sec-code

学完一些简单的基础知识后，可以尝试看看下列文章，感觉都讲的不错

JAVA代码审计之路
https://www.cnblogs.com/afanti/p/13156152.html
这篇文章写得也很不错
1、java审计-通俗的理解并审出自己的第一个漏洞
https://xz.aliyun.com/t/9173#toc-0
2、JAVA代码审计 | 因酷网校在线教育系统
https://xz.aliyun.com/t/2646
3、某oa审计1
https://xz.aliyun.com/t/9225
4、某oa审计2
https://xz.aliyun.com/t/9226
5、某教育java漏洞SSO
https://xz.aliyun.com/t/8132

1、Java 基础 Java SE

  1. 基础定义：
  2.     类class——人类    对象object——小明    方法function——吃饭

四种修饰符的区别
image.png
构造方法

  1. 构造方法是在创建对象的时候执行初始化操作
  2. 例如person p = new persion()
  3. 此时的persion()就是一个构造方法
  4. 当想自己定义一个构造方法的时候  public 类名(){};
  5. 构造方法没有返回值类型，全靠外部来输出

常用类库

  1. java.applet 提供了创建applet需要的所有类
  2. java.awt.* 提供了创建⽤户界⾯以及绘制和管理图形、图像的类
  3. java.beans.* 提供了开发Java Beans需要的所有类
  4. java.io 提供了通过数据流、对象序列以及⽂件系统实现的系统输⼊、输出
  5. java.lang.* Java编程语⾔的基本类库
  6. java.math.* 提供了简明的整数算术以及⼗进制算术的基本函数
  7. java.rmi 提供了与远程⽅法调⽤相关的所有类
  8. java.net 提供了⽤于实现⽹络通讯应⽤的所有类
  9. java.security.* 提供了设计⽹络安全⽅案需要的⼀些类
  10. java.sql 提供了访问和处理来⾃于Java标准数据源数据的类
  11. java.test 包括以⼀种独⽴于⾃然语⾔的⽅式处理⽂本、⽇期、数字和消息的类和接⼝
  12. java.util.* 包括集合类、时间处理模式、⽇期时间⼯具等各类常⽤⼯具包
  13. javax.accessibility 定义了⽤户界⾯组件之间相互访问的⼀种机制
  14. javax.naming.* 为命名服务提供了⼀系列类和接⼝
  15. javax.swing.* 提供了⼀系列轻量级的⽤户界⾯组件，是⽬前Java⽤户界⾯常⽤的包
  16. 注：在使⽤Java时，除了java.lang外，其他的包都需要import语句引⼊之后才能使⽤

继承

  1. ⼦类拥有⽗类⾮ private 的属性、⽅法。
  2. ⼦类可以拥有⾃⼰的属性和⽅法，即⼦类可以对⽗类进⾏扩展。
  3. ⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法。
  4. Java 的继承是单继承，但是可以多重继承，单继承就是⼀个⼦类只能继承⼀个⽗类，多重继承就是，例如 A 类继承 B 类， B 类继承 C 类，所以按照关系就是 C 类是 B 类的⽗类， B 类是 A 类的⽗类，这是 Java 继承区别于 C++ 继承的⼀个特性。
  5. 提⾼了类之间的耦合性（继承的缺点，耦合度⾼就会造成代码之间的联系越紧密，代码独⽴性越差）

封装

  1. 对成员属性访问控制类型为private,外界想要访问需要创造get和set开头的方法来进行调用

多态

  1. 多态的实现是重写，接口和抽象
  2. 重写——重写建立在继承的基础上，可以建立新的特性，例如父类为animal，子类为Dog继承animal,在拥有原本的特性的时候，还多了一个吃骨头的方法。
  3. 重载——重载和重写很容易混淆，但是它不建立新的特性，而仅仅是传参的类型和个数改变。
  5. 接口和抽象两个很特殊：
  6. 接口和抽象不能创建对象
  7. 以门和门铃举例：
  8. 1、抽象类1和接口类2都有开、关两种功能   现在想要有一个报警功能
  9. 2、现在临时有个厂家想定制一个门，有报警  还能正常开关
  10. 3、因此我们如果要改的话，把三种功能都放抽象类1里，但是之后以后不一定会生成有报警的门了，那报警这个功能就浪费了
  11. 4、把三种功能都放接口里，但是以后要是单独扩充了业务只想生产报警器，那么不具备开关的条件，就无法制作了
  12. 5、因此最好的方法就是抽象类中放开关，报警单独放一个类
  13. 6、简单的来说，接口更适合小而精，抽象更适合整体的高度耦合。

枚举

  1. 可以精简代码的长度，例如定义四个变量
  2. public static final int spring =1 
  3. public static final int summer =2 ....四个变量这样太过繁琐
  4. 而枚举则可以定义为 
  5. public enum season{
  6. spring ,summer ,.....
  7. }
  8. 相较于更加精简。

注解

  1. 注解被编译器读取并处理
  2. 注解以@注释名(参数)来存在，如@suerping(value='aaa')
  3. 最常见的就是@override  重写

补充知识（基础的快速的了解一下）

1、基础的jsp学习以及（servelt）
2、mybatis 的基础学习
3、Hibernate的基础学习
mybatis：机械工具，使用方便，拿来就用，但工作还是要自己来作，不过工具是活的，怎么使由我决定。
hibernate：智能机器人，但它（学习、熟练度）的成本很高，工作都可以摆脱他了，但仅限于它能做的事
4、spring 大框架初步学习
AOP IOC等
5、spring mvc
6、springboot
现在挺多用spring boot来进行开发，但是前提要先学会spring
7、Dubbo

四大模块MVC

一般的java架构都是由四大模块组成
1、View 视图层，在java里经常使用jsp文件来进行视图层的渲染，jsp文件里放的不全Java代码，而是js和html以及少量Java代码。
2、Controller层 控制层 也就是接受参数的，常见的就是servlet，requestmapping之类的写代码的地方
3、Server层 服务层 也叫作业务层，是具体实现功能的地方，这样方便控制层直接一个new类直接实例化，或者是implements，当然有时候业务功能也可能直接写在控制层就里。在标准SPring MVC常常是一个接口。
4、DAO层 持久层，我认为也是叫做数据层，增删改查，常常是一个接口

JSP的Servlet

学习资料：https://www.bilibili.com/video/BV1TQ4y1d7mQ?p=13

1、Servlet的注解与配置
提供了Servlet功能的服务器叫做Servlet容器，如Tomcat,Jetty,weblogic,Jboss,WebSphere。

使用注解进行配置访问路径:此时访问路径为http://127.0.0.1/hello

  1. /**
  2. 1、继承HttpServlet实现Servlet规范
  3. 2、重写service方法（或者重写doGet、doPost）
  4. 3、设置注解、或配置xml文件
  5. **/
  6. @WebServlet("/hello")
  7. public class HelloServlet extends HttpServlet{
  8.     protected void service (HttpServletRequest req,HttpxxxxResponse resp){
  9.     System.out.println("hello");
  10.     resp.getWrite().write("hello");
  11.     }
  12.     protected void doGet(HttpServletRequest request, HttpServletResponse response)
  13.         throws ServletException, IOException {
  14.         this.doPost(request, response);
  15.     }
  16.     protected void doPost(HttpServletRequest request, HttpServletResponse response)
  17.         throws ServletException, IOException {
  18.         //String username = request.getParameter("username");
  19.         //String password = request.getParameter("password");
  21. }

使用web.xml进行配置访问路径:此时访问路径为http://127.0.0.1/hello1

  1.     <servlet>
  2.         <servlet-name>helloword</servlet-name>
  3.         <servlet-class>com.controller.helloServlet</servlet-class>
  4.     </servlet>
  6.     <servlet-mapping>
  7.         <servlet-name>helloword</servlet-name>
  8.         <url-pattern>/hello1</url-pattern>
  9.     </servlet-mapping>

与Spring MVC的区别：https://blog.csdn.net/ysf15609260848/article/details/106651532

2、接受请求的几种常见方法
以http://www.baidu.com/aa/ssss?name=ice为例
获取请求时的完整路径：Srting url= request.getRequestURL()+””;
结果 http://www.baidu.com/aa/ssss
获取请求时的部分路径：String uri=request.getRequestURI();
结果 /aa/ssss
获取请求时的参数字符串：String queryString=request.getQueryString();
结果 name=ice
获取请求方式：Srting method=request.getMethod();
结果 GET/POST/PUT/DELETE
获取当前协议版本：String protocol=request.getProtocol
结果 HTTP/1.1
获取项目站点名：String webapp=request.getContextPath()
结果 /aa (这个看Tomcat的配置)

获取请求参数：request.getParmater(“name”)
获取请求同一参数的所有值（复选框传值）：request.getParmaterValues(“name”)

3、请求转发
请求转发
request.getRequestDispatcher(“/jsp/index.jsp”).forward(request, response);
重定向
response.sendRedirect(“//jsp/index.jsp”);

4、request作用域

Spring

学习材料——https://www.bilibili.com/video/BV1WZ4y1P7Bp?from=search&seid=4854599220786876145

1、通过ApplicationContext来注册bean
ApplicationContext context = new ClassPathXmlApplicationContext(“services.xml”, “daos.xml”);

2、实例化bean的三种方式
1、
2、
3、

https://blog.csdn.net/u012702547/article/details/56021922

3、依赖注入（DI）实现IOC
1、构造器注入
2、SET注入 https://blog.csdn.net/qq_41618008/article/details/115283059
3、接口注入

SET注入又有两个扩展注入 P命名空间和C命名空间
P命名空间
实体类中必须有set方法
C命名空间
实体类中必须存在有参构造器

4、Spring配置文件很多，因此可以将xml分块使用Import引入配置xml

5、Spring注解
Spring原始注解主要用来代替Bean配置
例如 可以变成@Component(“user”)
image.png
然后再applicationContext里配置一个组件扫描，让他扫描注解

Spring新注解——新注解就是多了几个关键词(可以代替原来)
https://blog.csdn.net/qq_39668869/article/details/100751817
1627570691(1).png

6、SpringMVC
路由路径可以看web.xml，也可以看注解
注解简单，但是耦合性强，不方便改动。
web.xml直观，配置工程量较大，解耦。
xml的优先级会高于注解的优先级
image.png
image.png
7、SpringMVC数据响应
页面跳转
直接返回字符串
image.png
通过MOdelAndView返回——多了一个ModelAndView对象
image.png
回写数据
直接返回字符串
1、response.getWrite().Print(“xxxxxxxxxxxxxxxxxxx”)
2、或者使用@ResponseBody+return “xxxx”
返回对象或集合

8、SpringMVC接受数据请求
可以看到不用进行一个request.getParameter()的参数赋值了
1、public void save(String username) 基本参数类型
2、public void save(User user) POJO参数类型
3、public void save(String[] strs) 数组参数类型

9、静态资源放行
经常有静态资源找不到，例如JS，CSS，原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是 /（缺省）
只要在spring-mvc.xml添加
——找不到的默认使用tomcat来找资源
或者

10、Spring-MVC中文编码乱码问题
配置filter
image.png
11、参数绑定注解
@RequestParm参数
1、value——解决前后端开发不一致，如前端传参为name，后端参数为username
2、required——解决传参不规范报错问题
3、defaultValue——打开网页就进行默认传参
image.png
RequestParam用来处理 Content-Type 为 application/x-www-form-urlencoded 编码的内容，Content-Type默认为该属性。@RequestParam也可用于其它类型的请求，例如：POST、DELETE等请求

@RequestBody 注解参数
接受的参数是来自requestBody中，一般用于接受处理非 Content-Type: application/x-www-form-urlencoded编码格式的数据，比如：application/json、application/xml等类型的数据。

12、restful
使用@PathVariable+ /user/{id}进行占位符的匹配
image.png

13、获取请求头
在spring MVC里使用@requestHeader 类似request.getHeader(name)，如下图可获得agent的值
image.png
@CookieValue 可以获得指定的Cookie得值
image.png
14、文件上传
1、文件上传统用的类为commons-fileupload,在pom.xml写入
2、配置文件上传解析器（spring里通用）
image.png
3、写文件上传代码
image.png

15、拦截器和过滤器的区别
SpringMVC拦截器只能对方法进行拦截
image.png、
下图所示就是拦截器的一个特征，进行自定义的代码配置要进行的动作
image.png
配置spring-mvc.xml，告诉spring我的拦截器在哪里，要匹配啥资源
image.png
如下图所示，传入参数param=yes即可访问资源，在实际情况中，可以将其进行SESSION的匹配
image.png

16、AOP
AOP依托于动态代理完成，但是是使用了配置来进行结合
主要解决的问题是在不改变源代码的情况下，增加新的功能。
1628070491.jpg
看到上面的术语头都大了！
简单的来说我们要知道的几个意思如下：
1、目标对象——这里的目标是一个类，你想给日志类多一个update的功能，这个日志类就是目标对象
2、连接点——比如日志类有一个add方法，这个add方法就是连接点，你可以
1、通知——给类增强的逻辑，
前置通知——在方法之前执行
后置通知——方法之后执行
异常通知——方法出现异常执行
最终通知
环绕通知

知道了相关术语的意思后，大概要知道整个AOP的开发是如何。
image.png
1、导入相关坐标，如下图所示，导入下图POM依赖
image.png
2、创建目标对象和切面对象，就是写两个普通的类
目标对象如下
image.png
切面对象
image.png

3、创建配置文件
image.png
4、编写测试类，调用save方法，此时运算结果就是我们在调用save时，同时调用了myAspect
image.png
结果如下
image.png

Spring Boot

Struts2

学习资料：
https://www.bilibili.com/video/av75374433/ 这个视频很快，可以快速过一下
https://www.bilibili.com/video/BV1Bb411x7Ex?from=search&seid=5179518835497216720
这个比较长，声音比较模糊，听起来比较难受

1、识别struts2
1）看pom.xml是否导入struts2
2）看是否有配置web.xml，如下图所示就是所有的请求都经过struts2，image.png
3、到了配置struts.xml 这个是struts2的灵魂配置文件，struts-config.xml文件时struts1.x时的配置文件
如下图所示，我们有个helloAction实现Action接口，使用execute()来执行这个类，execute()类似servlet里的dopost和doget请求
image.png
在struts.xml里进行配置，让struts2框架知道我们做了啥，可以看到给他了一个name和class，如果执行这个name返回为success，就重定向到index.jsp http://127.0.0.1/hello——302——》[http://127.0.0.1/](http://127.0.0.1/hello)index.jsp
image.png
记得配置后缀，下列表示后缀为action.do为后缀，那么该请求就变为 http://127.0.0.1/hello.do

2、Struts2接受参数的五种方法
1、第一种获取参数的方法，使用get,set方法来进行获取，此时name和massage可为外部传参）GET/POST都可以
image.png
https://www.cnblogs.com/printN/p/6438142.html

3、struts2的Actionsupport以及路由配置问题(动态调用方法)
struts可以继承ActionSupport类，也可以不继承，继承的好处是此类实现了很多实用的接口，提供了很多默认的方法，可以大大简化action的开发

如下图所示为继承了ActionSupport的一个类，写好了login方法和regist方法
image.png
将login方法和register方法进行struts.xml文件的配置，如下图所示，值得一提的是namespace=”/user”，那么我们路径就要跟上这个namespace，如果没写，那么默认就是namespace=”/“
这也就意味着请求方法路径为http://127.0.0.1/user/login.do
动态调用方法1：
image.png
如上图所示，login和register的路由配置有部分冗余，因此可以进行合并

动态调用方法2：
开启调用方法——
如下图所示，路由请求变为http://127.0.0.1/user/user!register.do
http://127.0.0.1/user/user!login.do
image.png

动态调用方法3：
其实struts2不推荐使用方法2来进行路由配置，因为这样的话很容易让别人知晓代码结构。
使用通配符
image.png
那么此时路径变为http://127.0.0.1/user/loginUser.do
http://127.0.0.1/user/registerUser.do

类似配置：

  1. <action name="chapter_*" class="chapter4.action.ChapterAction" method="{1}">
  2.     <result name="success">/WEB-INF/JspPage/chapter/chapter_{1}.jsp</result>
  3. </action>

4、默认Action
当访问默认不存在的方法时，重定向到error.jsp（如果没有该配置会报错泄露部分信息）

  1. <default-action-ref name="default"></default-action-ref>  （写在struts.xml前面点的为止）
  2. <action name="default" class="com.xxxx">
  3.     <result name="success">/error/xxxx/error.jsp</result>
  4. </action>

5、请求转发重定向
dispatcher

  1. <result name="success">/1.jsp</result>  
  2. 默认为dispatcher转发，地址栏不会变

redirect

  1.    <result name="success"  type="redirect">/1.jsp</result>  
  2.    重定向，302，地址栏变化，当前请求的参数和数模默认在下个页面不能使用

redirctAction

  1.    <result name="success"  type="redirctAction">/1.action/do</result>  
  2.    和redirect类似  不过redirectAction是重定向到另外的Action类里

chain

  1.    <result name="success"  type="chain">/hello</result>  
  2.            和redirctAction一样都是请求到另外的Action类里
  3.            和dispatcher一样的都是进行转发，而不是重定向
  4.            chain类型不用写后缀名，默认可携带参数进行传递

动态调用页面/转发
通过调用某个写好的类来进行转发，如page类 http://127.0.0.1/page=login 此时服务器直接转发login.jsp

  1. <default-action-ref name="default"></default-action-ref>  （写在struts.xml前面点的为止）
  2. <action name="default"  class="com.xxx">
  3.     <result name="success">${page}.jsp</result>
  4. </action>

6、获取Servlet-API
在Servlet里有HttpServletRequest这类对象代表客户端的请求，那么我们在struts2里想用Servlet API怎么用呢？
方式1：解耦
Struts2默认将Servlet API里的对象封装成Map，我们可以通过实现ActionConetxt类来进行获取
如下图所示
image.png
方式2：耦合
使用原生的Servlet对象，导入Pom.xml 名为servlet-api的依赖
https://blog.csdn.net/lushuaiyin/article/details/7017931
image.png

7、表单标签
Strust2提供了JSTL标签类似的标签库
常用的:
<s:submit =< input type=”submit”

使用如下判断语句，当我们后端接受了一个username参数时，return到1.jsp下，1.jsp内容如下时
页面就会自动判断username的值来进行返回字符文本
管理员
测试
非管理员

用于遍历集合
可接受后端实例化后的集合或前段传入的集合来进行遍历

遍历list集合(当list内容为对象时)，在直接取对象里的值

image.png

8、数据校验
用户在进行前端输入的时候，常常会乱输，我们可以进行前段校验，但是前端所有东西都是不安全的
因此我们可以使用vaildate方法来进行数据校验，vaildate继承与ActionSupport类

当你写了一个Action类时，并通过struts.xml将主要的方法注册成功，且在该类里面写了一个validate方法，此时默认该类存在vaildate数据校验的功能，具体功能判断可自定义
image.png
此时如果输入不符合数据校验的数据则会进行报错
image.png
原因是因为当类里有vaildate()时，先执行该vaildate里的内容，如果不匹配，就会返回一个Input常量(SUCCESS、NONE、ERROR、INPUT、LOGIN)
因此要在struts.xml里增加一行来接受Input值，此时就不会报错，而是直接进行转发
xxxxx.jsp
image.png
但是这样不是很不明显吗，啥错了都不知道！?
在xxx.jsp里加上
即可回显报错errorMessage的信息
image.png

9、方法校验
上述数据校验说道一个Action类里有vaildate()时，先执行该vaildate里的内容进行数据校验，这个类里的其他正常功能方法都会在通过它检验之后才能用，那么如果这个Action类的其他功能方法，有的不想要这个校验呢？
例如存在logon和register，login想校验复杂度，register不想校验复杂度
修改：
将vaildate()变为vaildateXxxx() 方法首字母大写
例如vaildateLogin()
image.png

10、校验框架——将vaildate()变为xml配置
需要在Action类的同个包下创建xml文件，文件命名为Action类的类名-validation.xml
如UserAction—validation.xml
如果你只想校验UserAction的login方法，那么就修改为UserAction-valLogin-validation.xml
image.png

11、struts2拦截器
过滤器和拦截器的区别：
　　①拦截器是基于Java的反射机制的，而过滤器是基于函数回调。
　　②拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
　　③拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
　　④拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
　　⑤在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
　　⑥拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

需要实现（implements ） Interceptor这个接口，里面有一个intercept方法，我们要实现这个方法，然后再struts.xml里进行配置
image.png
配置struts.xml，此时名为time的拦截器就会再该Action里配置成功
image.png
一定要默认引入”defaultSatack拦截器” ，这是struts2为了调用参数而默认内置的
image.png

12、文件上传
strust2的文件上传比较简单，
特征就是
private File Upload 有一个File类型的参数
ServletActionContext.getServletContext().getRealPath(“/xxxx”) 有一个获取绝对路径的实现
或者方法里有文件IO流FileInputStream以及FileoutputStream

https://blog.csdn.net/qq_33229669/article/details/80061475

13、文件下载
特征就是
private InputStream filename 有一个输出流参数

以及struts.xml配置文件里必须有的type=stream

  1. <action name="down"class="com.xx.action.FileDownloadAction">
  2.        <result name="success"   type="stream">
  3.              <param  name="bufferSize"> 1024  </param>
  4.               <param name="contentDisposition">attachment;fileName="${file}"</param>
  5.     </result> 
  6. </action>
  9. 基本配置就是这样，还有很多自定义的下载参数配置

关于spring和spring mvc 和spring boot
Spring 最初利用“工厂模式”（DI）和“代理模式”（AOP）解耦应用组件。大家觉得挺好用，于是按照这种模式搞了一个 MVC框架（一些用Spring 解耦的组件），用开发 web 应用（ SpringMVC ）。然后有发现每次开发都写很多样板代码，为了简化工作流程，于是开发出了一些“懒人整合包”（starter），这套就是 Spring Boot

  1. maven主要有两个功能，一是通过gav定位获取jar包，一是编译打包。
  2. 1、Spring boot 是 Spring 的一套快速配置脚手架，可以基于spring boot 快速开发单个微服务，Spring Cloud是一个基于Spring Boot实现的云应用开发工具；
  3. 2、Spring boot专注于快速、方便集成的单个个体，Spring Cloud是关注全局的服务治理框架；
  4. 3、spring boot使用了默认大于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置，Spring Cloud很大的一部分是基于Spring boot来实现。
  5. 4、Spring boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring boot，属于依赖的关系。
  6. 总结：
  7. springboot就是一个maven项目
  8. springboot是springcloud的基础，springcloud本身是springboot项目。
  9. 关系：maven->springboot->springcloud

spring的第一个项目
https://blog.csdn.net/weixin_44745147/article/details/107692078
https://blog.csdn.net/flyorfly/article/details/105449378

8、struts2
1、do后缀是早期struts1的后缀，同时spring的MVC的早期也是以do为后缀的
后来struts收购了webwork2后，将其简单封装，称为strutsTi，后来为了方便，同称struts2
2、Struts2 同时支持/ 和.do .action 这个和普通的jsp的servlet没有任何区别
3、struts2也是基于MVC框架的，但是与传统的MVC框架略有不同
4、struts2漏洞类型分为两种，一种是使用缩写的导航参数前缀时的远程代码执行漏洞，另一种是使用缩写的重定向参数前缀时的开放式重定向漏洞
5、Struts 2框架有两个核心配置文件，struts.xml和struts.properties，其中xml负责解析映射，properties负责一些基础配置
6、其实struts2就是代理了servlet的工作（本质是一样的），普通每写一个servlet在web.xml中都要做相应的配置。如果有多很servlet，会导致web.xml内容过于繁多
7、 Struts2利用过滤器，拦截客户端的请求。客户端发送请求，经过struts2的过滤器，将HttpServletRequest参数和HttpServletResponse参数封装，利用java反射机制将请求分派给映射的Action。根据Action的执行结果，转向其他Action或jsp页面
8、spring和strust2可以一起出现整合在一个项目里，原因是struts主要负责的是控制视图作用，类似于servlet或spring里的MVC，而更下层例如DAO层之类则可以单独使用spring的内容
因为spring boot > spring > spring MVC ~=~strust2

2、ClassLoader 类加载机制

  1. ClassLoader 默认使用AppClassLoader
  2. 类加载分为显示和隐式，显示即为java反射或classloader 隐式则为方法名（）,或new 
  3. URLClassloader 继承了ClassLoader

3、反射机制

  1. java 反射机制操作的是class对象，因此要先获取到class对象
  2. 反射机制的官方解释：
  3. 对于任意一个对象，都能动态调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
  4. 反射可以把java类的各种成分映射成对象，例如成员变量，方法，包等都是对象。
  1. 在java中，主要由以下类来实现反射：1、class类  位于java.lang包下  
  2. java.lang.reflect下
  3. 2、Field类  
  4. 3、method类 
  5. 4、constructor类
  6. 5、array类

想使用反射，首先就要获取操作类对应的Class对象，获取class对象的三种方法
image.png

  1. isInstance  判断一个对象所属的类
  2. newInstance 通过反射机制构造对象

https://www.cnblogs.com/ssooking/p/5875215.html

JAVA动态代理机制

JAVA反序列化

ysoserial

RMI和JNDI和LDAP

RMI和JNDI的关系
JNDI就象是url,记录着你要访问的地址
而RMI（远程方法调用）就象是http或是tcp,是一种连接方式
在很多情况下，LDAP和RMI可以互换

  1. https://xz.aliyun.com/t/8214   JNDI注入学习
  2. https://xz.aliyun.com/t/6633   JNDI注入原理及利用
  3. https://mp.weixin.qq.com/s/zf2FybRLHyeM9XbOXHYghQ     Java安全之JNDI注入
  4. https://blog.51cto.com/guojuanjun/1423392                 RMI原理揭秘之远程对象
  5. https://xz.aliyun.com/t/9053        Java安全之RMI反序列化                                                    
  6. http://blog.topsec.com.cn/java-jndi%E6%B3%A8%E5%85%A5%E7%9F%A5%E8%AF%86%E8%AF%A6%E8%A7%A3/
  7. JAVA JNDI注入知识详解

RMI——让一个JVM调用另一个JMV的远程类（前提是先实现java.RMI.remote接口类的方法）
执行一个远程方法的流程
1、Client获取Stub里的host和Port信息，会序列化自己请求时的数据，对Registry进行连接
2、registry接受序列化的数据，将请求调度到remote object上，然后返回结果给Client，依旧是序列化
3、client接受序列化请求，将其反序列化，返回给调度器
4、因此RMI的传输过程是基于序列化和反序列化的，因此就有安全问题
5、传输时候使用的协议叫JRMP，他传输对象是就是基于序列化和反序列实现

java.IO.Filesystem

  1. https://my.oschina.net/u/4944872/blog/4902301

java设计模式

Java IO/NIO读写

  1. java se内置了java.io 和java.nio两种文件系统
  2. nio效率比io高很多，io面向流，nio面向缓冲区

java本地命令执行

  1. 此处学习的命令执行更多地方用于jsp免杀的学习
  2. java.lang.Runtime类的exec方法来执行本地系统命令
  3. Runtime类的exec最终调用的是ProcessBuilder

JNI安全基础

  1. java基于C语言实现，java底层的API是通过JNI来进行调用的，通过JNI接口，可以实现C/C++与java的相互调用，来弥补java自身的一些不足
  2. JND定义native方法只需要添加native关键字

EL表达式注入

看这篇文章就够了
https://xz.aliyun.com/t/7692#toc-0

双亲委派总结：

在JVM里有多种ClassLoader，主要分成以下四个大类。
1、BootstrapclassLoader ，主要负责加载核心类库，java.lang.*
2、ExtClassLoader ，负责加载Jre/lib/ext下的扩展Jar包
3、AppClassLoader，负责加载应用程序的主函数
4、此外还有一个自定义ClassLoader

jvm 对 class 文件采用的是按需加载的方式，当需要使用该类时，jvm 才会将它的 class 文件加载到内存中产生 class 对象
当加载一个hello.class文件时，首先考虑我们的自定义加载器是否加载了，如果加载过，那么就直接结束。
然后之后检查AppClassLoader，如果加载了，那么就结束，如果没加载，那就继续往上到ExtClassLoader；ExtClassLoader 加载器会看是否加载，如果还是没加载，那就到BootstrapclassLoader。
此时BootstrapclassLoader为加载器的最上层，在上面就没有父加载器了，此时就会考虑自己是否能够加载，如果不能够加载（类型不对），那么就开始下沉。一直到最底层，如果都不能够加载的话（乱写），那么就抛出ClassNotFoundException。

为啥要用双亲委派：
1、避免重复加载
2、数据安全
3、防止核心类库被篡改（唯一性）

面试题：
能不能自己写个类叫java.lang.System？

通常情况下不行，因为类加载采用双亲委派技术，这样可以保持父类优先，只要父类一开始就加载了，那么子类就没有机会得到加载。而java.lang属于核心类库被BootstrapclassLoader
所加载，因此自己写的就没机会了。
但是我们可以自己自定义一个类加载器达到目的， 由于系统自带的三个类加载器都加载特定目录下的类 ，所以我们的类加载器也要放在特殊的目录下，只要三个父类都无法加载就行了。

一些以前认识到的的Tips

1、JSP根本是一个简化的Servlet设计,主要用来提供Web服务，类似PHP

2、Java Servlet是小服务器程序，使用java写的服务端程序，主要永不能够交互式的浏览和修改数据，生成Web内容（有点像是一个管理Web服务的接口，能让我们更好的对JSP页面进行管理，并且赋予一些特殊的机制，例如赌博网站需要实时显示比率，需要定时刷新页面的功能）。

Servlet其实就是后端的代码，因为前段JSP文件常常用于写HTML文件，如果全部都在JSP里会显得很杂乱，类似于asp.net中的cs和asp的关系。

给Servlet提供的服务的中间件，例如jetty weblogic tomcat jboss websphere

3、weblogic不开源，不免费，Tomcat开源免费

4、EJB 全称是企业Java Beans，主要的设计目标与核心应用是部署分布式应用程序。简单来说就是把已经编写好的程序(即:类)打包放在服务器上执行，EJB的技术基础是RMI

5、RPC 远程过程调用协议，通过网络从远程计算机上请求调用某种服务

6、RMI 远程方法调用 可以RMI是RPC的一种Java的实现，可以让你可以远程调用对象就像在本地调用一样，你可以参照点外卖，把外卖(对象)叫到你家里(本地客户)使用，依赖于JRM[P通讯协议

7、LDAP 轻型目录访问协议 是用来为查询，浏览，搜索而优化的数据库，

8、JRMP 远程消息交换协议，是用于Java RMI过程中的协议，只有使用这个协议，方法调用双方才能正常的进行数据交流

9、JNDI 全称为java名词目录接口，JNDI提供统一的客户端API

10、COBAR 公共对象请求代理体系结构，是一个结构（抽象）

CORBA结构分为三部分：
naming service 目录
client side 人
servant side 内容
三个部分之间的关系就好比人看书，naming service担任着书中目录的角色，人(client side)从目录(naming service)中找具体内容(servant side)。

11、IIOP 全称互联网内部对象请求代理协议，主要是用来在COBAR 的对象请求代理之间交流的协议

12、IDL 全称接口定义语言

13、AJP协议 Tomcat定义了两种连接器，一个HTTP Connector，一个AJP Connector，其中HTTP connector主要用来和外部链接，成为一个真正的Web服务器。
AJP则是与另一个Web容器进行交互

14、一些比较危险的java代码
getParameter()
getcookies()
getQueryString()写
gettheaders()
Runtime.exec()
logger.info()

15、SOAP 基于XML的协议，它使应用程序通过HTTP进行请求
image.png

16、反序列化工具ysoserial
在反序列化漏洞利用过程都会用到这个工具

17、maven是什么玩意？
就是用来管理Java项目的东西，可以理解成存在pom.xml的项目都是maven项目。