JSON

简述

json就是指js对象，但是json并不只是适用于js，很多编程语言都有针对json的解析器，比如Java和C++。json因为具有优良的数据交换性能，所以市面上的xml格式交互主要被json替代，而xml成为配置文件。

  1. var country = {name:"中国", province:[{name:"黑龙江",cities:["哈尔滨","大庆"]},
  2.                                         {name:"广东",cities:["广州","深圳"]},
  3.                                         {name:"台湾",cities:["高雄","台北"]},
  4.                                         {name:"新疆",cities:["乌鲁木齐","喀什"]}]}
  5. console.log(country.province[3].cities[0])
  1.  var pro ={
  2.       "name":"中国",
  3.       "province":[{"name":"黑龙江",”cities”:["哈尔滨","大庆"]},
  4.                   {"name":"广东","cities":["广州","深圳","珠海"]},
  5.                   {"name":"台湾","cities":["台北","高雄"]},
  6.                   {"name":"新疆","cities":["乌鲁木齐"]}]
  7.           }

上下两种有什么区别呢？
上面：json
下面：json字符串
通俗的理解为java里面的对象以及调用了toString方法，传输数据一般用json字符串。

使用

这里，格式转换比较麻烦的话，可以使用谷歌的Gson，阿里巴巴的fastjson，和sun格式自带的Jackson，这里以maven引入Jackson为例，说明格式转换工具的使用。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.simon</groupId>
  8.     <artifactId>jsonmvc</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>junit</groupId>
  14.             <artifactId>junit</artifactId>
  15.             <version>4.12</version>
  16.         </dependency>
  18.         <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
  19.         <dependency>
  20.             <groupId>com.fasterxml.jackson.core</groupId>
  21.             <artifactId>jackson-databind</artifactId>
  22.             <version>2.12.4</version>
  23.         </dependency>
  25.         <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
  26.         <dependency>
  27.             <groupId>com.fasterxml.jackson.core</groupId>
  28.             <artifactId>jackson-core</artifactId>
  29.             <version>2.12.1</version>
  30.         </dependency>
  32.         <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
  33.         <dependency>
  34.             <groupId>com.fasterxml.jackson.core</groupId>
  35.             <artifactId>jackson-annotations</artifactId>
  36.             <version>2.12.2</version>
  37.         </dependency>
  39.     </dependencies>
  41. </project>
  1. package com.simon;
  3. public class User {
  4.     private String username;
  5.     private String password;
  7.     public User() {
  8.     }
  10.     @Override
  11.     public String toString() {
  12.         return "User{" +
  13.                 "username='" + username + '\'' +
  14.                 ", password='" + password + '\'' +
  15.                 '}';
  16.     }
  18.     public String getUsername() {
  19.         return username;
  20.     }
  22.     public void setUsername(String username) {
  23.         this.username = username;
  24.     }
  26.     public String getPassword() {
  27.         return password;
  28.     }
  30.     public void setPassword(String password) {
  31.         this.password = password;
  32.     }
  34.     public User(String username, String password) {
  35.         this.username = username;
  36.         this.password = password;
  37.     }
  38. }

Java对象转为json字符串

  1. package com.simon;
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import com.fasterxml.jackson.databind.type.CollectionType;
  6. import com.fasterxml.jackson.databind.type.TypeFactory;
  7. import org.junit.Test;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. public class JSONTest {
  13.     @Test
  14.     public void testObject2Json() throws JsonProcessingException {
  15.         User user1 = new User("zs", "123");
  16.         User user2 = new User("ls", "234");
  17.         User user3 = new User("ww", "345");
  18.         User user4 = new User("zl", "456");
  20.         List<User> list = new ArrayList<>();
  21.         list.add(user1);
  22.         list.add(user2);
  23.         list.add(user3);
  24.         list.add(user4);
  26.         ObjectMapper mapper = new ObjectMapper();
  27.         String s = mapper.writeValueAsString(list);
  28.         System.out.println(s);
  30.     }
  31. }

image.pngimage.png

json字符串转为Java对象

  1. package com.simon;
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import com.fasterxml.jackson.databind.type.CollectionType;
  6. import com.fasterxml.jackson.databind.type.TypeFactory;
  7. import org.junit.Test;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. public class JSONTest {
  14.     //这里需要无参构造器
  15.     @Test
  16.     public void testJson2Object() throws JsonProcessingException {
  17.         String jsonStr = "[{\"username\":\"zs\",\"password\":\"123\"}," +
  18.                 "{\"username\":\"ls\",\"password\":\"234\"}," +
  19.                 "{\"username\":\"ww\",\"password\":\"345\"}," +
  20.                 "{\"username\":\"zl\",\"password\":\"456\"}]\n";
  21.         ObjectMapper mapper = new ObjectMapper();
  22.         TypeFactory typeFactory = mapper.getTypeFactory();
  23.         CollectionType type = typeFactory.constructCollectionType(List.class, User.class);
  24.         List<User> userObjects = mapper.readValue(jsonStr, type);
  25.         for (User user : userObjects) {
  26.             System.out.println(user);
  27.         }
  28.     }
  29. }

MVC

需求

用户注册登录案例：要求是先将数据以json文件的形式进行存储数据，后面将其改成使用数据库来存储，但是逻辑不变，只是将数据存储方式做一个改变。

MVC设计模式

MVC设计模式主要的一个点就在于解耦性，将模块和模块之间的关联尽可能降到最低。

  • Model：一般情况下由对象bean以及对用户的操作，可能有登录、 注册、查询、修改、删除
  • View：视图。就是对model里面数据模型的一个显示。比如说京东app，我的页面、订单页面。订单页面是一个视图，视图里面的数据怎么来的呢？一般是先查询数据库，将数据封装到一个order对象，order对象里面的数据显示在页面上面。数据库里面的内容——> Bean对象———> 页面、视图
  • controller：控制器。请求先分发到controller中，controller去调用模型的一个或者多个方法，比如请求分发到servlet，servlet去调用模型的注册方法，根据模型方法的返回值不同，调用不同的视图。


如果从json迁移到mysql，我们需要做的事情有哪些？
1、由RegisterJsonModel迁移到RegisterMysqlModel，如果希望代码的改动尽可能少，那么应当尽可能满足以下几点：①方法的名称要相同 ②方法的参数要相同 ③方法的返回值要相同
2、注册里面，变更，需要从RegisterJsonModel迁移到RegisterMysqlModel，如果还有其他的逻辑，比如登录、查询、修改、删除等逻辑。全部也都要将RegisterJsonModel迁移到RegisterMysqlModel（变更的地方依然有很多），于是想到接口，因为天然具有规范性，就能够规范这三点必须满足要求，否则会报错。

MVC三层架构

在MVC基础上，将程序的代码进行进一步的解耦，分为三个层：
展示层：servlet和视图组成的这个部分叫做展示层，做一些获取请求参数、校验、调用service
业务层：发起一个一个的dao方法调用，调用完毕之后，组装，形成需要的格式，返回给servlet（汽车工厂，会向各个零部件厂商发起订单，部件全部堆在生产车间之后，它取组装，形成一个整车）
数据层：就是单纯的一个一个的方法

变化过程

先是因为需求变更，不得不将可重复利用的代码片段复用，形成Bean及对Bean的操作、给用户的显示、用于解耦或是联系前两者的操作，这样的风格称为MVC设计模式。后来，在MVC设计模式的基础上，当遇到更复杂的逻辑时，可以将之前的操作进一步抽离，形成接口，以防止修改现有代码。
image.png

请求及执行过程

来自狂神说总结，链接点我

很久很久以前

image.png

后来

image.png
1638866499726_E2FD741A-DA02-422c-9CCC-333040575A08.png