首先对于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)

在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));
    }

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

一般来讲在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的协变和逆变：

首先JWT全程是 JSON WEB TOKEN

与Spring进行一个整合：

获取JWT

首先需要在pom中引入几个需要的jar包：

1
2
3
4
5
6
7
8
9
10
11

<dependency>
     <groupId>com.auth0</groupId>
     <artifactId>java-jwt</artifactId>
     <version>3.3.0</version>
   </dependency>
   <dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.0</version>
   </dependency>
   <dependency>

异步上传文件：

用Jquery的异步上传文件的时候需要引入一个js文件jquery.form.min.js，用这个文件里面的$.ajaxSubmit()方法来实现一个异步的文件上传功能。

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

$(this).ajaxSubmit({
           type:'POST',
           url: "/uploadfile",
           dataType: 'json',
           data: serializeData,
           contentType: false,
           cache: false,
           processData:false,
           beforeSubmit: function() {
       },
       uploadProgress: function (event, position, total, percentComplete){
       },
       success:function(){

       },
       error:function(data){
           alert('上传图片出错');
       }
   });

在这里的话$("")函数需要是form的id，而且beforeSubmit可以在上传文件之前可以做一些检查，例如文件后缀或者文件大小之类的检查。

在后端的话接受上传的文件其实跟Servlet差不多，主要是从request中获取请求流，参数的话需要标记为这个 @RequestParam("file") MultipartFile file,最后在SpringMvc中有一个方法可以将上传的文件通过移动或者复制然后转移到我们指定的文件夹中：

Redis启动

首先开启redis服务，windows的redis下载在github windows的redis下载地址,然后解压出来最后开启那个redis-server。
启动之后显示如下图：

spring配置：

配置

在Spring中也可以通过配置文件redis.properties配置，但是由于在这个项目中的配置文件已经太多了，所以选择使用类的方式进行配置:

Spring出现乱码的解决办法：

若需要快速的解决乱码问题可以直接看配置文件:

后台逻辑：

在项目中的web.xml中添加Spring的字符过滤器，配置如下：

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

<filter>
        <filter-name>SpringEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>SpringEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

前言：

在之前写了一篇spring和shiro的一个整合，但是在那个项目中并没有使用注解，而且没有加入权限，只是加入了角色，所以在这篇日志中将这个项目添加注解并且加入权限。

开启Shiro的注解：

刚开始开启这个注解的时候，添加了但是一直无效。

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

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
         String username = (String) principalCollection.getPrimaryPrincipal();
         List<Resources> resources =loginservice.getRoleById(username);
         List<String> roles =new ArrayList<String>();
         for (Resources  r: resources){
             roles.add(r.getRole());
         }
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.addRoles(roles);
        if( !username.equals("MANAGER") ){
            return info ;
        }else {
            List<String> pre = new ArrayList<String>();
            pre.add("user:insert");
            info.addStringPermissions(pre);
            return info;
        }

    @RequestMapping("/toinsert")
    @RequiresPermissions("user:insert")
    public String toinsert(){
        return "getuser/userINsert";
    }