mybatis的orderby

在使用mybatis的时候，一般来讲是使用#{}这种方式来设置sql的参数，因为mybatis在解析sql的时候的时候对于使用#{}的参数首先会解析成?,然后再加入参数。具体可以看mybatis的解析日志：

1
2

DEBUG [main] - ==>  Preparing: select * from clazzentity where clazz_name = ? 
DEBUG [main] - ==> Parameters: 一年级(String)

但是在mybatis中如果需要使用groupby和orderby的话就需要注意不可以使用#了，因为使用#的话会导致解析出来的参数自动的带了一个引号,而使用$的话就会直接把参数带进去，所以在进行groupby的时候是需要使用$来进行参数的替换的。但是在使用${}这个的时候需要注意下。

mybatis的多参数和单参数

今天遇到一个需求，需要将Excel中的一些数据导入到mysql中，由于之前接触到了Python的Pandas，所以这个时候便想到了Python，但是连接数据库的时候出现了问题，所以便写一个文章记录下。

解决办法：

1. 下载Mysql_Python的一个exe文件
2. 注意tosql的这个方法使用的类。pd.io.sql.to_sql
3. 注意添加index=False防止出现出入的时候多了一个index

sqlalchemy方式连接

导入库

首先对于Mybatis来说，如果是直接复制mysql里面的语句粘贴到mybatis的mapper文件里面去的话很容易导致user读取出错，假设在mysql中select * from user XX，若直接把这条sql语句复制到mapper文件中的话会导致user会成为mapper文件中的关键字

在Mybatis的使用中，有时候会出现需要一对多的场景，尤其是在插入的过程中，即假设存在A，B两表。A表对B表是一对多的关系，在插入数据的过程中需要先插入A表，通过A表返回的主键然后再进行B表的查询，这个时候一般有两种操作。

方法一：首先获取A表的主键，然后通过for循环进行B表的插入
方法二：使用mybatis的foreach进行多条语句的插入

在这里的话主要是记录下第二种方法，即通过mybatis的foreach来实现多条语句的插入:

建立数据库表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

mysql> select * from clazz;
+----------+------------+
| CLAZZ_ID | CLAZZ_NAME |
+----------+------------+
|        1 | 一年级     |
+----------+------------+
1 row in set (0.00 sec)


mysql> select * from student;
+----------+--------+----------+
| CLAZZ_ID | STU_ID | STU_NAME |
+----------+--------+----------+
|        1 |    101 | a        |
|        1 |    102 | b        |
+----------+--------+----------+
2 rows in set (0.00 sec)

在使用git的时候单独一人进行push和pull的时候是不会出现代码冲突的，但是当团队中有多人的时候进行协作的时候难免会造成代码间同步问题。
具体就是git pull的时候会提示线上代码会覆盖本地的代码。然后就不让pull，最后也不让push。查询了下解决办法：

方法一：

1
2
3

git stash
git pull 
git stash pop

但是这种方法pull下来的代码会导致IDEA识别不了。也就是java文件会直接不显示，最后是关闭IDEA然后再次打开才解决这个问题的。重新导入的时候选择maven

方法二：

在Java里面，List转为Array是调用的Java的一个Arrays.copyOf()这个方法，查看了下源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public Object[] toArray() {
        return Arrays.copyOf(this.elementData, this.size);
    }

 public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }

 public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }


 public static Object newInstance(Class<?> componentType, int length)
        throws NegativeArraySizeException {
        return newArray(componentType, length);
    }

在这里需要注意的是在copyOf()方法中的那个三元表达式，也就是说在这里无论执行的true还是false，都会返回一个新的数组对象。而在这里有一行代码就是((Object)newType == (Object)Object[]).class)，这一句看起来没什么，其实可以看参数Class<? extends T[]> newType和Object会发现这两个数组对象都被强转成了Object，而==`比较符是不能比较不同类型的。例如：

1
2
3
4

public void te(){
        System.out.println("ad" == 2);
        System.out.println((String.class == Object.class));
    }

上面的代码在代码的编译期就会被提示==不可以适用于上述的两种情况.如下：

今天突然想知道在访问一个网站的时候那些请求头是在何时被加上去的。例如访问百度的时候，host和refer或者其他的字段是在七层模型的哪一层被加入的。

Wireahark抓包

在这里尝试了下百度的抓包，但是百度的是是HTTPS的连接，导致一直找不到那个HTTP连接，所以还是放弃了，但是随后又找了一个非HTTPS的网站，进行抓包，然后测试了下，发现可以

解析抓包

这是用wireshark抓取的结果：


却发现这里多了一个Hypertext Transfer Protocol，在这里的话因为是GET请求，所以准备用POST请求再次尝试：

发现其实内容都差不多，那也就证明了这些请求头都是在应用层被添加进去的。
那么在这些抓包中可以看到他的层次是5层，而并非是7层模型。在这里的的五层模型分别是物理层,数据连续层,网络层,传输层,应用层。相较于7层的OSI模型少了会话层和表示层。

一般来讲在Spring中可以直接加@ResponeBody来直接返回Json格式的数据，但是这样又有点别扭，因为Stirng同时也可以返回视图名称，但是加了@ResponseBody之后便可以返回Json了，为了解决这个问题还有一种解决办法就是指定一个Result来实现序列化接口然后直接返回这个对象，最后在spring-mvc.xml这个配置文件中配置解析器就可以了。

添加依赖：

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

<dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.5</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.5</version>
    </dependency>

配置spring-mvc.xml依赖：

1
2
3
4
5
6

<mvc:annotation-driven>
       <mvc:message-converters>
           <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
           <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
       </mvc:message-converters>
   </mvc:annotation-driven>

为什么需要泛型

在Java中其实Object这个类已经可以解决大部分的泛型问题了，那么现在为什么还需要泛型了，一种说法是为了安全，因为在编译期使用泛型的话便可以基本确定这个参数的类型了，但是使用Object的话，由于Object是所有类型的超类，所以这会给代码造成一定的安全性问题。

1
2
3
4
5
6
7

public void testList(T t){
        List<Object> list =new ArrayList<>();
        List<T> list1 =new ArrayList<>();
        list.add(1);
        list.add("1");
        list.add(t);
    }

在上面的例子中，list1由于其类型是T，这就会导致在向list1中插入数据的时候只能是泛型T，但是对于list而言，由于Object是所有类的超类，那么这个list就可以插入任何值了，所以这就导致了一些安全问题

关于Java的协变和逆变：

对于Manacher算法自己研究了一会，总算是理解了其中的含义，乘着有时间正好可以过来记录下：

思路：

1. 将字符串变成奇数，通过加非字符串里面的符号表示，不过一般都是加的#
2. 找出以当前索引为中点的最长回文数长度，并且记录，例如：#a#b#a,这个字符串所对应的长度便是[1,2,1,2,1,1],因为在#的时候组成不了回文，所以#这里是1，而到了a这里，因为#a#组成了回文，所以a的最长回文字符串长度是2,以此类推
3. for循环开始比较，在这里一般来讲是首先需要定义一个字符串的边界变量，以防止数组越界，另外一个就是最长回文字符串的中点坐标，以此类推就可以

代码：

将填充符号计入到需要匹配的的字符串中