精华内容
下载资源
问答
  • 目录创建大分类创建功能表生成代码创建module并导入生成的代码修改自己module的pom.xml和ruoyi-admin下的pom.xml运行效果 创建大分类 进入系统管理—》菜单管理,新添一个大分类 创建功能表 在数据库创建自己的功能...

    创建大分类


    进入系统管理—》菜单管理,新添一个大分类

    在这里插入图片描述

    创建功能表


    在数据库创建自己的功能表,根据自己需求来创建。

    在这里插入图片描述

    生成代码


    1. 进入系统工具—》代码生成—》导入,导入刚刚创建的功能表;
    2. 点击编辑修改基本信息和生成信息,可以直接照葫芦画瓢就好;
    3. 点击生成代码并下载到本地,解压生成的代码包,执行里面生成的sql文件,用于更新菜单信息;

    在这里插入图片描述在这里插入图片描述
    这里注意字段描述、字段增删改查以及字段类型,如设置下拉框,需要同时设置字典类型,字典类型可以在后台先添加(一般直接数据库添加更快),字典类型如性别(0男 1女)、使用状态(0禁用 1启用)。

    在这里插入图片描述

    在这里插入图片描述
    以上设置完成点保存,在以下列表点击生成代码、解压,把解压目录下的sql文件执行一下,用于更新菜单,最后直接复制代码、粘贴搞定。
    在这里插入图片描述
    在这里插入图片描述

    创建module并导入生成的代码


    右键new—》project—》maven module创建自己的module,当然了也可以直接导入刚刚生成的代码到默认的module去也行,更加方便;

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    删掉module下main目录下的所有文件,然后复制刚刚生成的代码进来;
    在这里插入图片描述

    导入子模块


    如果已有相关模块,也可以直接导入进来;

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    修改自己module的pom.xml和ruoyi-admin下的pom.xml


    自己module修改如下,根据需求而定,不要复制我的,版本可能不同,看看demo里的版本,对应一下即可。

    <?xml version="1.0"?>
    <project
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    	xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    	<parent>
    		<artifactId>ruoyi</artifactId>
    		<groupId>com.ruoyi</groupId>
    		<version>4.3.1</version>
    	</parent>
    	<modelVersion>4.0.0</modelVersion>
    
    	<artifactId>ruoyi-test</artifactId>
    
    	<description>
    	    test模块
    	</description>
    
    	<dependencies>
    
    		<!--velocity代码生成使用模板 -->
    		<dependency>
    			<groupId>org.apache.velocity</groupId>
    			<artifactId>velocity</artifactId>
    		</dependency>
    
    		<!-- 通用工具 -->
    		<dependency>
    			<groupId>com.ruoyi</groupId>
    			<artifactId>ruoyi-common</artifactId>
    		</dependency>
    
    	</dependencies>
    </project>
    ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200709212725213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1MzUwNjU0,size_16,color_FFFFFF,t_70#pic_center)
    

    ruoyi-admin下的module添加如下

      <!-- 代码生成测试-->
            <dependency>
                <groupId>com.ruoyi</groupId>
                <artifactId>ruoyi-test</artifactId>
                <version>4.3.1</version>
            </dependency>
    

    在这里插入图片描述

    运行效果


    完成以上步骤后,重启一下程序,重新登录后台即可看到自己刚刚创建的功能模块效果了;

    在这里插入图片描述

    若依官网:http://doc.ruoyi.vip/
    特别感谢:若依开源框架

    展开全文
  • SpringBoot JPA 自动生成代码 (一) 生成实体类

    万次阅读 多人点赞 2019-09-28 10:15:31
    现在换了SpringBoot,自动生成代码使用的是人人开源项目修改来的,可以直接生成简单的CRUD代码和HTML页面。 一次偶然的机会,帮群里一个老弟看代码时,发现他们自动生成代码是用的JPA,之前听说过这个,但是没有用过...

    之前做SSM项目时,一直使用的是Mybatis的Generator自动生成代码工具,也是蛮好使的。现在换了SpringBoot,自动生成代码使用的是人人开源项目修改来的,可以直接生成简单的CRUD代码和HTML页面。

    一次偶然的机会,帮群里一个老弟看代码时,发现他们自动生成代码是用的JPA,之前听说过这个,但是没有用过,所以也是一脸懵逼的。于是查了查怎么用,之后发现也是很神奇的,也是可以直接生成实体类,然后Dao层和Service直接继承就可以完成简单的CRUD了,自己刚接触,这里记录一下简单的使用过程。

    今天是第一次使用JPA生成代码,在查了半天之后,发现自动生成的脚本的样式是千奇百怪的,那个老弟还非要按照别人的代码格式生成,但是人家又不给他生成代码的脚本,让他自己百度找,对于小白的我就很懵逼了。

    这里使用的是IDEA,其自带的生成实体类的脚本Generate POJOs.groovy有点过于简单了,那么下面先看看自带的这个脚本怎么用。

    首先是打开DataSource
    在这里插入图片描述
    这时会在右边弹出如下图的窗口,由于我这里已经添加过数据库了,第一次打开会提示使用Alt + Insert 进行添加数据库,我这里使用的是MySQL。
    在这里插入图片描述
    在这里插入图片描述
    输入需要连接的数据库的信息,然后点击左下角的下载工具,然后点击Test Connection,如果提示Success 证明连接成功了,这时点击Apply,ok即可。
    在这里插入图片描述
    下面还是使用的之前添加的jpa-demo这个数据库,可以看到这里只有一张User表,我们就拿这个来生成。

    右键我们需要生成实体类的表格,这里可以多选,可以看到如下图。如果使用默认的脚本,可以直接点击最后的Generate POJOs.groovy,这里我们简单的扩展一下,自定义我们自己的脚本。
    在这里插入图片描述
    可以看到,IDEA跳转到这个页面了,这个文件的内容就是系统自动带的生成实体类的脚本。
    在这里插入图片描述
    第一次用的时候没有仔细看,直接按照网上的博客直接生成了,感觉蛮神奇的,后来发现生成的跟那个项目里面别人写的不一样,这才反应过来,看一下这个脚本文件的内容,发现这个脚本也是有固定的套路的。

    这里贴上一个简单的生成实体类的脚本,可以随意自己定制:

    import com.intellij.database.model.DasTable
    import com.intellij.database.model.ObjectKind
    import com.intellij.database.util.Case
    import com.intellij.database.util.DasUtil
    
    import java.text.SimpleDateFormat
    
    /*
     * Available context bindings:
     *   SELECTION   Iterable<DasObject>
     *   PROJECT     project
     *   FILES       files helper
     */
    packageName = ""
    typeMapping = [
            (~/(?i)tinyint|smallint|mediumint/)      : "Integer",
            (~/(?i)int/)                             : "Long",
            (~/(?i)bool|bit/)                        : "Boolean",
            (~/(?i)float|double|decimal|real/)       : "BigDecimal",
            (~/(?i)datetime|timestamp|date|time/)    : "Date",
            (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",
            (~/(?i)/)                                : "String"
    ]
    
    
    FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->
        SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }
    }
    
    def generate(table, dir) {
        def className = javaName(table.getName(), true)
        def fields = calcFields(table)
        packageName = getPackageName(dir)
        PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File(dir, className + ".java")), "UTF-8"))
        printWriter.withPrintWriter { out -> generate(out, className, fields, table) }
    
    //    new File(dir, className + ".java").withPrintWriter { out -> generate(out, className, fields,table) }
    }
    
    // 获取包所在文件夹路径
    def getPackageName(dir) {
        return dir.toString().replaceAll("\\\\", ".").replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";"
    }
    
    def generate(out, className, fields, table) {
        out.println "package $packageName"
        out.println ""
        out.println "import javax.persistence.Column;"
        out.println "import javax.persistence.Entity;"
        out.println "import javax.persistence.Table;"
        out.println "import javax.persistence.Id;"
        out.println "import javax.persistence.GeneratedValue;"
        out.println "import java.io.Serializable;"
        Set types = new HashSet()
    
        fields.each() {
            types.add(it.type)
        }
    
        if (types.contains("Date")) {
            out.println "import java.util.Date;"
        }
    
        if (types.contains("BigDecimal")) {
            out.println "import java.math.BigDecimal;"
        }
    
        if (types.contains("InputStream")) {
            out.println "import java.io.InputStream;"
        }
        out.println ""
        out.println "/**\n" +
                " * @Description  \n" +
                " * @Author  linmengmeng\n" + //1. 修改idea为自己名字
                " * @Date " + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " \n" +
                " */"
        out.println ""
        out.println "@Entity"
        out.println "@Table ( name =\"" + table.getName() + "\" , schema = \"\")" //2. schema = \"后面添加自己的表空间名称(mysql可以不添加, 不用这个schema属性也行)
        out.println "public class $className  implements Serializable {"
        out.println ""
        out.println genSerialID()
        fields.each() {
            out.println ""
            // 输出注释
            if (isNotEmpty(it.commoent)) {
                out.println "\t/**"
                out.println "\t * ${it.commoent.toString()}"
                out.println "\t */"
            }
    
            if ((it.annos+"").indexOf("[@Id]") >= 0) out.println "\t@Id"
    
            if (it.annos != "") out.println "   ${it.annos.replace("[@Id]", "")}"
    
    
            // 输出成员变量
            out.println "\tprivate ${it.type} ${it.name};"
        }
    
        // 输出get/set方法
        fields.each() {
            out.println ""
            out.println "\tpublic ${it.type} get${it.name.capitalize()}() {"
            out.println "\t\treturn this.${it.name};"
            out.println "\t}"
            out.println ""
    
            out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"
            out.println "\t\tthis.${it.name} = ${it.name};"
            out.println "\t}"
        }
    
        // 输出toString方法
        out.println ""
        out.println "\t@Override"
        out.println "\tpublic String toString() {"
        out.println "\t\treturn \"{\" +"
        fields.each() {
            out.println "\t\t\t\t\t\"${it.name}='\" + ${it.name} + '\\'' +"
        }
        out.println "\t\t\t\t'}';"
        out.println "\t}"
    
        out.println ""
        out.println "}"
    }
    
    def calcFields(table) {
        DasUtil.getColumns(table).reduce([]) { fields, col ->
            def spec = Case.LOWER.apply(col.getDataType().getSpecification())
    
            def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value
            def comm = [
                    colName : col.getName(),
                    name    : javaName(col.getName(), false),
                    type    : typeStr,
                    commoent: col.getComment(),
                    annos   : "\t@Column(name = \"" + col.getName() + "\" )"]
            if ("id".equals(Case.LOWER.apply(col.getName())))
                comm.annos += ["@Id"]
            fields += [comm]
        }
    }
    
    // 这里是处理数据库表前缀的方法,这里处理的是t_xxx命名的表
    // 已经修改为使用javaName, 如果有需要可以在def className = javaName(table.getName(), true)中修改为javaClassName
    // 处理类名(这里是因为我的表都是以t_命名的,所以需要处理去掉生成类名时的开头的T,
    // 如果你不需要去掉表的前缀,那么请查找用到了 javaClassName这个方法的地方修改为 javaName 即可)
    def javaClassName(str, capitalize) {
        def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
                .collect { Case.LOWER.apply(it).capitalize() }
                .join("")
                .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
        // 去除开头的T  http://developer.51cto.com/art/200906/129168.htm
        s = s[1..s.size() - 1]
        capitalize || s.length() == 1 ? s : Case.LOWER.apply(s[0]) + s[1..-1]
    }
    
    def javaName(str, capitalize) {
    //    def s = str.split(/(?<=[^\p{IsLetter}])/).collect { Case.LOWER.apply(it).capitalize() }
    //            .join("").replaceAll(/[^\p{javaJavaIdentifierPart}]/, "_")
    //    capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]
        def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)
                .collect { Case.LOWER.apply(it).capitalize() }
                .join("")
                .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")
        capitalize || s.length() == 1 ? s : Case.LOWER.apply(s[0]) + s[1..-1]
    }
    
    def isNotEmpty(content) {
        return content != null && content.toString().trim().length() > 0
    }
    
    static String changeStyle(String str, boolean toCamel) {
        if (!str || str.size() <= 1)
            return str
    
        if (toCamel) {
            String r = str.toLowerCase().split('_').collect { cc -> Case.LOWER.apply(cc).capitalize() }.join('')
            return r[0].toLowerCase() + r[1..-1]
        } else {
            str = str[0].toLowerCase() + str[1..-1]
            return str.collect { cc -> ((char) cc).isUpperCase() ? '_' + cc.toLowerCase() : cc }.join('')
        }
    }
    
    //生成序列化的serialVersionUID 
    static String genSerialID() {
        return "\tprivate static final long serialVersionUID =  " + Math.abs(new Random().nextLong()) + "L;"
    }
    
    

    脚本里面的注释相信已经可以帮你进行自定义自己的脚本了,在自定义的时候,需要注意有个方法generate,这里面有个生成文件的方法,里面的参数需要保持一致,在我第一次修改整合几个不同的模板的时候,就因为这个报错了,后来检查了半天才发现这个问题。
    在这里插入图片描述

    脚本修改完了之后,就是自动生成了,还是打开之前的DataSource,右键需要生成的表,开始生成。由于上面脚本中packageName是默认的,这里会有弹窗,需要我们选择生成实体类的位置。
    在这里插入图片描述
    在这里插入图片描述
    修改之后,再次生成,可以直接覆盖掉原来生成的文件,这点还是蛮方便的。脚本生成的实体类如下:

    package com.lin.model.jpaDemo.entity;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.Table;
    import javax.persistence.Id;
    import javax.persistence.GeneratedValue;
    import java.io.Serializable;
    
    /**
     * @Description  
     * @Author  linmengmeng
     * @Date 2019-09-28 11:06:00 
     */
    
    @Entity
    @Table ( name ="user" , schema = "")
    public class User  implements Serializable {
    
    	private static final long serialVersionUID =  7415787526169091091L;
    
    	/**
    	 * 主键ID
    	 */
    	@Id
       	@Column(name = "id" )
    	private Long id;
    
    	/**
    	 * 姓名
    	 */
       	@Column(name = "name" )
    	private String name;
    
    	/**
    	 * 年龄
    	 */
       	@Column(name = "age" )
    	private Long age;
    
    	/**
    	 * 邮箱
    	 */
       	@Column(name = "email" )
    	private String email;
    
    	public Long getId() {
    		return this.id;
    	}
    
    	public void setId(Long id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return this.name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Long getAge() {
    		return this.age;
    	}
    
    	public void setAge(Long age) {
    		this.age = age;
    	}
    
    	public String getEmail() {
    		return this.email;
    	}
    
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    	@Override
    	public String toString() {
    		return "{" +
    					"id='" + id + '\'' +
    					"name='" + name + '\'' +
    					"age='" + age + '\'' +
    					"email='" + email + '\'' +
    				'}';
    	}
    
    }
    
    展开全文
  • 人人开源地址 使用git clone 将generator...接下来就要配置数据库信息,因为需要逆向生成代码 需要生成那个数据库的信息就修改url后的数据库名 然后就去配置properties文件 #代码生成器配置信息 # 主路径 #mainP...

    人人开源地址
    使用git clone 将generator项目克隆到本地
    在这里插入图片描述
    将代码生成器放入到项目中(去掉项目本身的git信息)
    在这里插入图片描述
    使用IDE打开父项目(是需要生成东西的项目)
    在这里插入图片描述
    将代码生成器项目加入到子模块中
    在这里插入图片描述
    接下来就要配置数据库信息,因为需要逆向生成代码
    在这里插入图片描述
    需要生成那个数据库的信息就修改url后的数据库名

    然后就去配置properties文件

    #代码生成器配置信息
    
    # 主路径
    #mainPath=io.renren
    mainPath=com.wrial
    #包名
    package=com.wrial.mall
    # 模块名
    moduleName=product
    #作者
    author=wrial
    #Email
    email=2806935450@qq.com
    # 表前缀 pms开头
    tablePrefix=pms_
    
    #\u7C7B\u578B\u8F6C\u6362\uFF0C\u914D\u7F6E\u4FE1\u606F
    tinyint=Integer
    smallint=Integer
    mediumint=Integer
    int=Integer
    integer=Integer
    bigint=Long
    float=Float
    double=Double
    decimal=BigDecimal
    bit=Boolean
    
    char=String
    varchar=String
    tinytext=String
    text=String
    mediumtext=String
    longtext=String
    
    date=Date
    datetime=Date
    timestamp=Date
    
    NUMBER=Integer
    INT=Integer
    INTEGER=Integer
    BINARY_INTEGER=Integer
    LONG=String
    FLOAT=Float
    BINARY_FLOAT=Float
    DOUBLE=Double
    BINARY_DOUBLE=Double
    DECIMAL=BigDecimal
    CHAR=String
    VARCHAR=String
    VARCHAR2=String
    NVARCHAR=String
    NVARCHAR2=String
    CLOB=String
    BLOB=String
    DATE=Date
    DATETIME=Date
    TIMESTAMP=Date
    TIMESTAMP(6)=Date
    
    int8=Long
    int4=Integer
    int2=Integer
    numeric=BigDecimal
    

    运行项目
    在这里插入图片描述
    可以看到运行在80端口,访问http://localhost:80
    在这里插入图片描述
    如下就可以展示出我们所有的表,并可以选择生成哪些
    在这里插入图片描述
    点击生成后会生成一个压缩包,将这个压缩包的main和项目的main进行合并,就会生成如下框架
    在这里插入图片描述
    还会生成前端文件,可以根据自身需求选择要不要
    在这里插入图片描述

    然后根据需求进行取舍,并导入相关依赖

    展开全文
  • 本次分享的是一个基于Mybatise 代码自动生成工具,只需要之前设计数据库,然后使用自动生成代码的工具类,可以将entity,mapper,service,Controller层自动生成。并且实现基础的功能,增删查改,以及分页等效果。先...

    开源中国中有很多优秀的开源项目可以供我们学习。

    本次分享的是一个基于Mybatise 代码自动生成工具,只需要之前设计数据库,然后使用自动生成代码的工具类,可以将entity,mapper,service,Controller层自动生成。并且实现基础的功能,增删查改,以及分页等效果。

    先分享一下网站 Mybatise-Plus。可以自行过去学习。本节主要讲基于 这个工具构建SSM 项目,并创建一个简单的接口

    首先设计数据库:

    很简单的一个表

    基于Maven 

    pom.xml

    工具类主要依赖

    <!-- Mybatis-Plus -->
    <dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>${mybaitsplus.version}</version>
    </dependency>

    下面是完整的pom.xml (包括Spring,jdbc,json,log 等)

    <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/maven-v4_0_0.xsd">
      <modelVersion>4.0.0</modelVersion>
      <groupId>com.nyist</groupId>
      <artifactId>WebSockUseMybatisePlus</artifactId>
      <packaging>war</packaging>
      <version>0.0.1-SNAPSHOT</version>
      <name>WebSockUseMybatisePlus Maven Webapp</name>
      <url>http://maven.apache.org</url>
      <properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<spring.version>5.0.0.RELEASE</spring.version>
    		<junit.version>4.12</junit.version>
    		<druid.version>1.1.0</druid.version>
    		<fastjson.version>1.2.8</fastjson.version>
    		<mybaitsplus.version>2.1.9</mybaitsplus.version>
    		<mysql.version>5.1.38</mysql.version>
    		<log4j.version>1.2.17</log4j.version>
    		<slf4j.version>1.7.19</slf4j.version>
    		<aspectjweaver.version>1.8.8</aspectjweaver.version>
    		<fileupload.version>1.3.1</fileupload.version>
    		<jstl.version>1.2</jstl.version>
    	</properties>
    
    	<dependencies>
    		<!-- JUnit -->
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>${junit.version}</version>
    			<scope>test</scope>
    		</dependency>
    
    		<!-- Spring -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context-support</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-tx</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-beans</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    
    		<!-- Spring MVC -->
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>${spring.version}</version>
    			<type>jar</type>
    			<scope>compile</scope>
    		</dependency>
    
    		<!-- AOP -->
    		<dependency>
    			<groupId>org.aspectj</groupId>
    			<artifactId>aspectjweaver</artifactId>
    			<version>${aspectjweaver.version}</version>
    		</dependency>
    		<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    		<dependency>
    		    <groupId>javax.servlet</groupId>
    		    <artifactId>javax.servlet-api</artifactId>
    		    <version>3.1.0</version>
    		    <scope>provided</scope>
    		</dependency>
    		
    		<!-- FileUpload -->
    		<dependency>
    			<groupId>commons-fileupload</groupId>
    			<artifactId>commons-fileupload</artifactId>
    			<version>${fileupload.version}</version>
    		</dependency>
    
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>jstl</artifactId>
    			<version>${jstl.version}</version>
    		</dependency>
    
    		<!-- Mybatis-Plus -->
    		<dependency>
    			<groupId>com.baomidou</groupId>
    			<artifactId>mybatis-plus</artifactId>
    			<version>${mybaitsplus.version}</version>
    		</dependency>
    
    		<!-- Mysql -->
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>${mysql.version}</version>
    		</dependency>
    
    		<!-- Druid -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>druid</artifactId>
    			<version>${druid.version}</version>
    		</dependency>
    
    		<!-- FastJson -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>${fastjson.version}</version>
    		</dependency>
    
    		<!-- Log -->
    		<dependency>
    			<groupId>log4j</groupId>
    			<artifactId>log4j</artifactId>
    			<version>${log4j.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-api</artifactId>
    			<version>${slf4j.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-log4j12</artifactId>
    			<version>${slf4j.version}</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-test</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<finalName>WebSockUseMybatisePlus</finalName>
    		<plugins>
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-compiler-plugin</artifactId>
    				<configuration>
    					<source>1.7</source>
    					<target>1.7</target>
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>
    </project>

    工具类:

    /**
     * <p>
     * 代码生成器演示
     * </p>
     */
    public class MySqlGenerator {
    
        /**
         * <p>
         * MySQL 生成演示
         * </p>
         */
        public static void main(String[] args) {
            AutoGenerator autoGenerator = new AutoGenerator();
            System.out.println("开始执行==");
            //全局配置
            GlobalConfig globalConfig = new GlobalConfig();
            globalConfig.setOutputDir("G:\\StudyWorkSpace\\WebSocketUseMybatisePlus\\WebSockUseMybatisePlus\\src\\main\\java");//自己的项目路径
            globalConfig.setFileOverride(true);
            globalConfig.setActiveRecord(true);
            globalConfig.setEnableCache(false);// XML 二级缓存
            globalConfig.setBaseResultMap(true);// XML ResultMap
            globalConfig.setBaseColumnList(false);// XML columList
            globalConfig.setAuthor("geYang");
            //生成文件名:
            globalConfig.setXmlName("%sMapper");
            globalConfig.setMapperName("%sMapper");
            globalConfig.setServiceName("%sService");
            globalConfig.setServiceImplName("%sImpl");
            globalConfig.setControllerName("%sController");
            
            autoGenerator.setGlobalConfig(globalConfig);
    
            // 数据源配置
            DataSourceConfig dataSourceConfig = new DataSourceConfig();
            dataSourceConfig.setDbType(DbType.MYSQL);
            dataSourceConfig.setTypeConvert(new MySqlTypeConvert(){
                // 自定义数据库表字段类型转换【可选】
                @Override
                public DbColumnType processTypeConvert(String fieldType) {
                    return super.processTypeConvert(fieldType);
                }
            });
            dataSourceConfig.setDriverName("com.mysql.jdbc.Driver");
            dataSourceConfig.setUsername("root");
            dataSourceConfig.setPassword("");
            dataSourceConfig.setUrl("jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf8");
            autoGenerator.setDataSource(dataSourceConfig);
    
            // 策略配置
            StrategyConfig strategyConfig = new StrategyConfig();
    //        strategyConfig.setCapitalMode(true);    // 全局大写命名 ORACLE 注意
            strategyConfig.setTablePrefix(new String[] { "yj_", "gy_", "d_", "t", "h_"});// 此处可以修改为您的表前缀
            strategyConfig.setNaming(NamingStrategy.underline_to_camel);
            strategyConfig.setInclude(new String[] { "gy_user" }); // 需要生成的表
            // strategy.setExclude(new String[]{"test"}); // 排除生成的表
            // 自定义实体父类
            // strategy.setSuperEntityClass("com.baomidou.demo.TestEntity");
            // 自定义实体,公共字段
            // strategy.setSuperEntityColumns(new String[] { "test_id", "age" });
            // 自定义 mapper 父类
            // strategy.setSuperMapperClass("com.baomidou.demo.TestMapper");
            // 自定义 service 父类
            // strategy.setSuperServiceClass("com.baomidou.demo.TestService");
            // 自定义 service 实现类父类
            // strategy.setSuperServiceImplClass("com.baomidou.demo.TestServiceImpl");
            // 自定义 controller 父类
            // strategy.setSuperControllerClass("com.baomidou.demo.TestController");
            // 【实体】是否生成字段常量(默认 false)
            // public static final String ID = "test_id";
            // strategy.setEntityColumnConstant(true);
            // 【实体】是否为构建者模型(默认 false)
            // public User setName(String name) {this.name = name; return this;}
            // strategy.setEntityBuliderModel(true);
            autoGenerator.setStrategy(strategyConfig);
    
            // 包配置
            PackageConfig packageConfig = new PackageConfig();
            packageConfig.setParent("com.demo");
            packageConfig.setController("controller");
            packageConfig.setXml("mybatis.mapper");
            autoGenerator.setPackageInfo(packageConfig);
    
            // 注入自定义配置,可以在 VM 中使用 cfg.abc 【可无】
            InjectionConfig injectionConfig = new InjectionConfig() {
                @Override
                public void initMap() {
                    Map<String, Object> map = new HashMap<String, Object>();
                    map.put("abc", this.getConfig().getGlobalConfig().getAuthor() + "-mp");
                    this.setMap(map);
                }
            };
    
            // 自定义 xxList.jsp 生成
            //List<FileOutConfig> focList = new ArrayList<FileOutConfig>();
            /*focList.add(new FileOutConfig("/template/list.jsp.vm") {
                @Override
                public String outputFile(TableInfo tableInfo) {
                    // 自定义输入文件名称
                    return "D://my_" + tableInfo.getEntityName() + ".jsp";
                }
            });
            cfg.setFileOutConfigList(focList);*/
            autoGenerator.setCfg(injectionConfig);
    
            
        // 调整 xml 生成目录演示
             /*focList.add(new FileOutConfig("/templates/mapper.xml.vm") {
                @Override
                public String outputFile(TableInfo tableInfo) {
                    return "/develop/code/xml/" + tableInfo.getEntityName() + ".xml";
                }
            });
            cfg.setFileOutConfigList(focList);*/
           // mpg.setCfg(cfg);
    
            // 关闭默认 xml 生成,调整生成 至 根目录
    //        TemplateConfig tc = new TemplateConfig();
    //        tc.setXml(null);
    //        mpg.setTemplate(tc);
    
            // 自定义模板配置,可以 copy 源码 mybatis-plus/src/main/resources/template 下面内容修改,
            // 放置自己项目的 src/main/resources/template 目录下, 默认名称一下可以不配置,也可以自定义模板名称
            // TemplateConfig tc = new TemplateConfig();
            // tc.setController("...");
            // tc.setEntity("...");
            // tc.setMapper("...");
            // tc.setXml("...");
            // tc.setService("...");
            // tc.setServiceImpl("...");
        // 如上任何一个模块如果设置 空 OR Null 将不生成该模块。
            // mpg.setTemplate(tc);
    
            // 执行生成
            autoGenerator.execute();
    
            // 打印注入设置【可无】
            System.err.println(autoGenerator.getCfg().getMap().get("abc"));
        }
    
    }
    连接完毕,之后运行main 函数

     (这里在自动生成代码后,还会有一个(com.nyist.Mapper)包,这里我已经将包中的配置文件移到resource中,所以看不到了。


    下面进行SSM环境搭建

    这里我的配置文件路径如图


    其中Mapper 文件是从之前自动生成的一过来的。当然可以在生成的时候指定路径

    mybatis-config.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD SQL Map Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <!--
     |   plugins在配置文件中的位置必须符合要求,否则会报错,顺序如下:
     |   properties?, settings?,
     |   typeAliases?, typeHandlers?,
     |   objectFactory?,objectWrapperFactory?,
     |   plugins?,
     |   environments?, databaseIdProvider?, mappers?
     |-->
    <configuration>
        <!--
         | 全局配置设置
         |
         | 可配置选项                   默认值,     描述
         |
         | aggressiveLazyLoading       true,     当设置为‘true’的时候,懒加载的对象可能被任何懒属性全部加载。否则,每个属性都按需加载。
         | multipleResultSetsEnabled   true,     允许和不允许单条语句返回多个数据集(取决于驱动需求)
         | useColumnLabel              true,     使用列标签代替列名称。不同的驱动器有不同的作法。参考一下驱动器文档,或者用这两个不同的选项进行测试一下。
         | useGeneratedKeys            false,    允许JDBC 生成主键。需要驱动器支持。如果设为了true,这个设置将强制使用被生成的主键,有一些驱动器不兼容不过仍然可以执行。
         | autoMappingBehavior         PARTIAL,  指定MyBatis 是否并且如何来自动映射数据表字段与对象的属性。PARTIAL将只自动映射简单的,没有嵌套的结果。FULL 将自动映射所有复杂的结果。
         | defaultExecutorType         SIMPLE,   配置和设定执行器,SIMPLE 执行器执行其它语句。REUSE 执行器可能重复使用prepared statements 语句,BATCH执行器可以重复执行语句和批量更新。
         | defaultStatementTimeout     null,     设置一个时限,以决定让驱动器等待数据库回应的多长时间为超时
         | -->
        <settings>
            <!-- 这个配置使全局的映射器启用或禁用缓存 -->
            <setting name="cacheEnabled" value="true"/>
            <!-- 全局启用或禁用延迟加载。当禁用时,所有关联对象都会即时加载 -->
            <setting name="lazyLoadingEnabled" value="true"/>
            <setting name="multipleResultSetsEnabled" value="true"/>
            <setting name="useColumnLabel" value="true"/>
            <setting name="defaultExecutorType" value="REUSE"/>
            <setting name="defaultStatementTimeout" value="25000"/>
        </settings>
    
    </configuration>

    Spring-mvc.xml

    <?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 http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
        <mvc:default-servlet-handler/>
    
        <!-- Controller包(自动注入) -->
        <context:component-scan base-package="com.nyist.controller"/>
    
        <!-- FastJson注入 -->
        <mvc:annotation-driven>
            <mvc:message-converters register-defaults="true">
                <!-- 避免IE执行AJAX时,返回JSON出现下载文件 -->
                <!-- FastJson -->
                <bean id="fastJsonHttpMessageConverter"
                      class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                    <property name="supportedMediaTypes">
                        <list>
                            <!-- 这里顺序不能反,一定先写text/html,不然ie下出现下载提示 -->
                            <value>text/html;charset=UTF-8</value>
                            <value>application/json;charset=UTF-8</value>
                        </list>
                    </property>
                    <property name="features">
                        <array value-type="com.alibaba.fastjson.serializer.SerializerFeature">
                            <!-- 避免循环引用 -->
                            <value>DisableCircularReferenceDetect</value>
                            <!-- 是否输出值为null的字段 -->
                            <value>WriteMapNullValue</value>
                            <!-- 数值字段如果为null,输出为0,而非null -->
                            <value>WriteNullNumberAsZero</value>
                            <!-- 字符类型字段如果为null,输出为"",而非null  -->
                            <value>WriteNullStringAsEmpty</value>
                            <!-- List字段如果为null,输出为[],而非null -->
                            <value>WriteNullListAsEmpty</value>
                            <!-- Boolean字段如果为null,输出为false,而非null -->
                            <value>WriteNullBooleanAsFalse</value>
                        </array>
                    </property>
                </bean>
            </mvc:message-converters>
        </mvc:annotation-driven>
    
        <!-- 静态资源配置 -->
        <mvc:resources mapping="/resources/**" location="/resources/"/>
    
        <!-- 对模型视图名称的解析,即在模型视图名称添加前后缀 -->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"/>
            <property name="suffix" value=".html"/>
        </bean>
    
        <!-- 上传限制 -->
        <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            <!-- 上传文件大小限制为31M,31*1024*1024 -->
            <property name="maxUploadSize" value="32505856"/>
        </bean>
    
    </beans>

    spring-mybaties.xml

    <?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:tx="http://www.springframework.org/schema/tx"
           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/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">
    
        <!-- 配置数据源 -->
        <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
            <property name="url" value="${jdbc_url}"/>
            <property name="username" value="${jdbc_username}"/>
            <property name="password" value="${jdbc_password}"/>
    
            <!-- 初始化连接大小 -->
            <property name="initialSize" value="0"/>
            <!-- 连接池最大使用连接数量 -->
            <property name="maxActive" value="20"/>
            <!-- 连接池最大空闲 -->
            <property name="maxIdle" value="20"/>
            <!-- 连接池最小空闲 -->
            <property name="minIdle" value="0"/>
            <!-- 获取连接最大等待时间 -->
            <property name="maxWait" value="60000"/>
    
            <property name="validationQuery" value="${validationQuery}"/>
            <property name="testOnBorrow" value="false"/>
            <property name="testOnReturn" value="false"/>
            <property name="testWhileIdle" value="true"/>
    
            <!-- 配置间隔多久才进行一次检测,检测需要关闭的空闲连接,单位是毫秒 -->
            <property name="timeBetweenEvictionRunsMillis" value="60000"/>
            <!-- 配置一个连接在池中最小生存的时间,单位是毫秒 -->
            <property name="minEvictableIdleTimeMillis" value="25200000"/>
    
            <!-- 打开removeAbandoned功能 -->
            <property name="removeAbandoned" value="true"/>
            <!-- 1800秒,也就是30分钟 -->
            <property name="removeAbandonedTimeout" value="1800"/>
            <!-- 关闭abanded连接时输出错误日志 -->
            <property name="logAbandoned" value="true"/>
    
            <!-- 监控数据库 -->
            <property name="filters" value="mergeStat"/>
        </bean>
    
        <!-- Spring整合Mybatis,更多查看文档:http://mp.baomidou.com -->
        <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"/>
            <!-- 自动扫描Mapping.xml文件 -->
            <property name="mapperLocations" value="classpath:mybatis/*/*.xml"/>
            <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
            <property name="typeAliasesPackage" value="com.nyist.*"/>
            <!-- <property name="typeEnumsPackage" value="com.baomidou.springmvc.model.enums"/> -->
            <property name="plugins">
                <array>
                    <!-- 分页插件配置 -->
                    <bean id="paginationInterceptor" class="com.baomidou.mybatisplus.plugins.PaginationInterceptor">
                    </bean>
                </array>
            </property>
    	    <!-- 全局配置注入 -->
    	    <property name="globalConfig" ref="globalConfig" />
    	</bean>
    	<bean id="globalConfig" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
    	    <!--
    			AUTO->`0`("数据库ID自增")
    		 	INPUT->`1`(用户输入ID")
    			ID_WORKER->`2`("全局唯一ID")
    			UUID->`3`("全局唯一ID")
    		-->
    	    <property name="idType" value="2" />
    		<!--
    			MYSQL->`mysql`
    			ORACLE->`oracle`
    			DB2->`db2`
    			H2->`h2`
    			HSQL->`hsql`
    			SQLITE->`sqlite`
    			POSTGRE->`postgresql`
    			SQLSERVER2005->`sqlserver2005`
    			SQLSERVER->`sqlserver`
    		-->
    		<!-- Oracle需要添加该项 -->
    	    <!-- <property name="dbType" value="oracle" /> -->
    	    <!-- 全局表为下划线命名设置 true -->
    	    <!-- <property name="dbColumnUnderline" value="true" /> -->
            <!-- <property name="metaObjectHandler">
                <bean class="com.baomidou.springmvc.common.MyMetaObjectHandler" />
            </property>
             -->
    	</bean>
    
        <!-- MyBatis 动态扫描  -->
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.nyist.mapper"/>
        </bean>
    
        <!-- 配置事务管理 -->
        <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"/>
        </bean>
    
        <!-- 事务管理 属性 -->
        <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
            <tx:attributes>
                <tx:method name="add*" propagation="REQUIRED"/>
                <tx:method name="append*" propagation="REQUIRED"/>
                <tx:method name="save*" propagation="REQUIRED"/>
                <tx:method name="update*" propagation="REQUIRED"/>
                <tx:method name="modify*" propagation="REQUIRED"/>
                <tx:method name="edit*" propagation="REQUIRED"/>
                <tx:method name="insert*" propagation="REQUIRED"/>
                <tx:method name="delete*" propagation="REQUIRED"/>
                <tx:method name="remove*" propagation="REQUIRED"/>
                <tx:method name="repair" propagation="REQUIRED"/>
    
                <tx:method name="get*" propagation="REQUIRED" read-only="true"/>
                <tx:method name="find*" propagation="REQUIRED" read-only="true"/>
                <tx:method name="load*" propagation="REQUIRED" read-only="true"/>
                <tx:method name="search*" propagation="REQUIRED" read-only="true"/>
                <tx:method name="datagrid*" propagation="REQUIRED" read-only="true"/>
    
                <tx:method name="*" propagation="REQUIRED" read-only="true"/>
            </tx:attributes>
        </tx:advice>
    
        <!-- 配置切面 -->
        <aop:config>
            <aop:pointcut id="transactionPointcut" expression="execution(* com.nyist.service..*.*(..))"/>
            <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice"/>
        </aop:config>
    
    </beans>
    

    spring.xml

    <?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:util="http://www.springframework.org/schema/util"
           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 http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    
        <!-- 引入属性文件 -->
        <context:property-placeholder location="classpath:config.properties"/>
    
        <!-- Service包(自动注入) -->
        <context:component-scan base-package="com.nyist.service"/>
    
        <import resource="classpath:spring/spring-mybatis.xml"/>
    </beans>

    config.properties (配置了数据库信息)

    validationQuery=SELECT 1
    jdbc_url=jdbc:mysql://127.0.0.1:3306/websockdemo?useUnicode=true&characterEncoding=UTF-8&tinyInt1isBit=false
    jdbc_username=root
    jdbc_password=123456

    最后在web.xml中配置拦截器等

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
    
      <display-name>Archetype Created Web Application</display-name>
      
       <!-- 加载Spring配置文件 -->
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/spring.xml</param-value>
        </context-param>
    
        <!-- 字符集 过滤器 -->
        <filter>
            <filter-name>encodingFilter</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>
        </filter>
        <filter-mapping>
            <filter-name>encodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
    
        <!-- Spring监听器 -->
        <listener>
            <description>Spring监听器</description>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
        <!-- 防止Spring内存溢出监听器 -->
        <listener>
            <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
        </listener>
    
        <!-- Spring MVC -->
        <servlet>
            <servlet-name>SpringMVC</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
                <description>SpringMVC</description>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:spring/spring-mvc.xml</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>SpringMVC</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>
    
        <!-- Session超时时间 -->
        <session-config>
            <session-timeout>15</session-timeout>
        </session-config>
    </web-app>

    开发一个接口(判断登录)

    package com.nyist.controller;
    
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.HttpServletBean;
    
    import com.nyist.entity.User;
    import com.nyist.service.UserService;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpMethod;
    import org.springframework.stereotype.Controller;
    
    /**
     * <p>
     *  前端控制器
     * </p>
     *
     * @author Mike.Zhang
     * @since 2018-06-12
     */
    @Controller
    @RequestMapping("/user")
    public class UserController {
    	@Autowired UserService service;
    	private Map<String,Object> map = new HashMap<String, Object>();
    	
    	@RequestMapping(value="/judgeLogin",method=RequestMethod.POST)
    	@ResponseBody
    	public Map<String,Object> judgeUser(@RequestParam("username")String uname,@RequestParam("password")String pass,HttpServletResponse response){
    		response.addHeader("Access-Control-Allow-Origin","*");
    		List<User> list = service.selectList(null);
    		int i =0 ;
    		for (User user : list) {
    			if(uname.equals(user.getUname())&&pass.equals(user.getPassword())) {
    				map.put("code", 1);
    				map.put("userid", user.getId());
    				map.put("msg", "success");
    				i = 1;
    				break;
    			} else {
    				continue;
    			}
    		}
    		if(i == 0) {
    			map.put("code", 0);
    			map.put("userid", null);
    			map.put("msg", "fail");
    		}
    		return map;
    	}
    }
    
    
    
    

    至此可以继续开发其他接口了


    展开全文
  • java代码自动生成UML

    千次阅读 2014-10-13 15:04:12
    jTracert是一个能够在Java程序运行期自动生成UML时序图(Sequence Diagram)的开源工具。可以利用这个工具快速理解/研究别人编写的代码。快速生成文档。 更多jTracert信息    GwtUml  ...
  • 开源Java生成二维码分享海报

    千次阅读 多人点赞 2019-05-05 07:24:38
    这一篇文章我们就用 Java生成一下仿金山词霸的海报。
  • SSH开源自动生成代码工具,可自动生成action、service、form、dao、model、vo、sqlmap.xml、.hbm.xml、test等 博客分类: java strutshibernatespringibatisoracle   本人只是将最流行的代码生成...
  • java代码自动生成UML-工具集

    万次阅读 2017-06-22 14:41:21
    在网上找了很多,要不就是过期没有更新,新版本Eclipse无法兼容,要不就是收费,后来终于在开源组织找到了能用的 ...使用java编写的开源UML产品,功能比较全。最受欢迎的UML建模工具。  更多ArgoUML信息 
  • lazy-generator JAVA代码自动生成的插件

    千次阅读 2017-04-28 16:17:43
    插件介绍改插件是基于 mybatis+mysql+eclipse的代码自动生成工具,旨在帮助程序源脱离枯燥的DAO层编辑 这个插件是开源的,项目托管到coding.net,项目地址为https://coding.net/u/hanchanghong/p/lazy/git 二.插件...
  • 【公众号回复 “1024”,免费领取程序员赚钱实操经验】大家好,我是你们的章鱼猫。很多网站会给默认登陆的用户生成默认的头像,包括 GitHub 其实就有,你想知道是怎么实现的么?今天的推...
  • 饿了么公司Android开源项目:一个易用的生成Comparator的工具类,在排序时特别有用。用户只用指定排序策略,此工具类就可以自动生成Comparator。
  • Java开发工具】Generator:Java代码生成工具

    万次阅读 热门讨论 2018-09-14 14:01:52
    在整个项目过程中耗费了不少的时间来构建SpringMVC的重复性代码和Mybatis的映射文件,同时我也越来越觉得这些重复且难度不大的工作不应当充斥于整个项目周期中,于是开始在网上搜寻Java代码生成器,但看了许多都不太...
  • gen-test-plugin ...本框架可以一键生成所有代码对应的 junit 测试案例,为你的人生节约宝贵的时间。 特性 支持生成 junit4/junit5 支持 jdk7 支持自定义生成模板 更新记录 更新记录 gen-test...
  • 整理一下自动生成代码的软件

    千次阅读 2018-05-29 09:43:36
    http://www.codesmithtools.com 官方论坛:http://forum.codesmithtools.com/default.aspx 版权形式:30天试用 开源:否 需要先注册确认后才能下载2:MyGeneratorMyGenerator是又一个国外很不错的代码生成工具,...
  • 声明,本人是一个新手程序员,以下内容只是个人理解,仅供参考,若有错误的地方欢迎指导 基于若依的二次开发 ...系统自带的代码生成工具 项目作者的原话: 就是这个 让我们看看里面都有啥 里面就是系统生成的...
  • JavaPoet - 优雅地生成代码

    万次阅读 2017-05-26 23:16:44
    JavaPoet - 优雅地生成代码JavaPoet - 优雅地生成代码 一项目简介 二项目总览 1 大体结构图 2 关键类说明 三相关使用 1 API使用 2 一个简单示例 四源码浅析 五使用场景 1 根据编译时注解生成代码 11 前言 12 一个...
  • android开发中使用greenado生成代码
  • 项目简介 ocean-code-generator采用(适用):,并使用maven...支持自动生成一个业务逻辑增删改查的后端controller、service、dao的代码,前端列表查询和单条数据的增删改查的vue代码。这里是后端代码,前端在http...
  • 使用 Google AutoValue 自动生成代码

    千次阅读 2016-05-11 18:35:43
    原文 ... 主题 谷歌 ...在 Java 中通常定义一个模型类时,需要定义一堆不同类型的成员变量,而且为了满足面向对象的基本特征,又要定义一堆相应的 ... IDE 可以很好的帮我们生成这些样板代码,但是如果看到一个
  • 注解处理101--自动生成代码

    千次阅读 2016-06-22 10:11:09
    注解处理 代码生成
  • Swagger Codegen是一个开源代码生成器,根据Swagger定义的RESTful API可以自动建立服务端和客户端的连接。Swagger Codegen的源码可以在Github上找到。 GitHub: https://github.com/swagger-api/swagger-codegen 二...
  • 众所周知,java程序如果要调用动态库(.so,.dll)的函数,最传统方式是使用JNI技术,用JNI写java调用接口代码是非常痛苦的,调试也是比较麻烦的事儿,JNA推出后,大大降低了开发难度,java程序员只要为对应的动态库...
  • JavaFast是一款基于代码生成器的智能快速开发平台,可以帮助解决java项目中80%的重复工作,让开发者更多关注业务逻辑。 既能快速提高开发效率,帮助公司节省人力成本,同时不失灵活性。 可以应用在任何J2EE项目的...
  • java开源

    千次阅读 2012-03-12 14:38:01
    java开源 - 简介 开源不是开放编译器的源代码. 通俗点说, 就是你写了一个软件, 然后把这个软件的源代码发布到网上, 让大家都可以学习,改进. 就是开源! 专业点说, 就是要符合一定的规范, 比如GPL等. ...
  • JavaFast是一款基于代码生成器的智能快速开发平台,可以帮助解决java项目中80%的重复工作,让开发者更多关注业务逻辑。 既能快速提高开发效率,帮助公司节省人力成本,同时不失灵活性。 可以应用在任何J2EE项目的...
  • Java JWT开源库综述

    千次阅读 2019-12-17 15:32:02
    Java JWT开源库综述
  • 代码生成代码 package com.dyp.dyptest.Generator; import com.baomidou.mybatisplus.generator.AutoGenerator; import com.baomidou.mybatisplus.generator.InjectionConfig; import ...
  • 格式更多,对W3C相关标准支持度高,格式定义可以完全脱离具体的Java代码,十分灵活,且控制力很强。缺点是大数据量时性能较差,默认中文支持不好。 目前的版本是0.95。具体代码: test.xml  1   xml version=...
  • 推荐几个代码自动生成器,神器!!!

    万次阅读 多人点赞 2019-06-23 22:15:46
    20个代码生成框架 老的代码生成器的地址:https://www.cnblogs.com/skyme/archive/2011/12/22/2297592.html 以下是大家推荐的最近很火爆的代码生成器神器。如果有更好的希望大家多多留言,我会及时补充上去。 ---...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,893
精华内容 55,557
关键字:

java自动生成代码开源

java 订阅