zoukankan      html  css  js  c++  java
  • 【maven + hibernate(注解) +spring +springMVC】 使用maven搭建项目

    研究,百度,查资料+好友帮助,使用MyEcplise2015工具,通过maven搭建hibernate+springMVC+spring的项目,数据库采用MySql5.5 不过使用的版本会在项目搭建过程中介绍。

    大概就是下面的几个步骤:

    1. 设计数据库,得到数据库

    2.使用maven搭建项目,导入包的依赖

    3.引入spring的配置信息,放在资源文件中

    4.引入Log4j日志文件配置

    5.配置hibernate

    6.配置ehcache.xml

    7.使用hibernate  tools生成实体

    8.创建Dao层、service层

    9.配置spring-mvc.xml

    10.配置web.xml容器

    11.创建Controller层

    12.创建view层

    13.打包,部署,运行项目

    1.设计数据库,并创建数据库

    1.1 使用powerDesigner,设计数据表,生成cdm

    设计三个数据表分别为角色表,权限表以及用户表,三张表之间分别是多对多的关系。三个实体的主键均使用UUID,因此设计主键长度为varchar(36)

    1.2 继续生成pdm

    由于三张表之间是多对多,生成两张中间表,分别是角色权限表和用户角色表

     这个怎么用就不介绍了,总而言之,最后生成SQL语句,然后在MySQL运行,创建一个新的数据库,生成如下的数据库:

    2.创建maven项目,导入项目所需依赖架包

    2.1创建maven项目

    新创建成的maven项目结构如下,我们将这个项目结构完善

    首先将这个项目转化为web项目,项目右键-->properties,在设置过程中,注意Web版本与jave版本的相互支持

    项目转成web项目之后,会生成下面的这个目录

    我们要做的就是把这个WebRoot目录下的东西放到src下的webapp下,让它符合maven项目的结构标准.然后,删除WebRoot目录即可。

    2.2 调一下项目中的小错误

    首先双击pom.xml文件,设置web版本

    双击Inxde.jsp文件,发现没有httpservlet架包,那我们就进入build path,给项目添加所支持架包

    既然改到这里了,我们的JRE版本太低了,把它替换成高的版本,顺便把J2EE的架包也搞进来,以备不时之需

    搞进来J2EE的lib

    搞进来JRE的lib

    此时,小错误全部消除完成,现在的项目结构如下所示:

    2.3 现在配置pom.xml。导入项目依赖架包

      1 <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">
      2   <modelVersion>4.0.0</modelVersion>
      3   <groupId>com.it</groupId>
      4   <artifactId>mySecond</artifactId>
      5   <version>0.0.1-SNAPSHOT</version>
      6   <packaging>war</packaging>
      7   <build>
      8       <plugins>
      9           <plugin>
     10               <artifactId>maven-war-plugin</artifactId>
     11               <configuration>
     12                   <version>3.0</version>
     13               </configuration>
     14           </plugin>
     15       </plugins>
     16   </build>
     17   
     18       <name>myAgen</name>
     19     <url>http://maven.apache.org</url>
     20 
     21     <properties>
     22         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     23         <spring.version>4.1.4.RELEASE</spring.version>
     24         <hibernate.version>4.3.8.Final</hibernate.version>
     25         <jackson.version>2.5.0</jackson.version>
     26         
     27     </properties>
     28 
     29     <dependencies>
     30 
     31         <!-- junit -->
     32         <dependency>
     33             <groupId>junit</groupId>
     34             <artifactId>junit</artifactId>
     35             <version>4.12</version>
     36             <scope>test</scope>
     37         </dependency>
     38 
     39         <!-- spring -->
     40         <dependency>
     41             <groupId>org.springframework</groupId>
     42             <artifactId>spring-core</artifactId>
     43             <version>${spring.version}</version>
     44         </dependency>
     45 
     46         <dependency>
     47             <groupId>org.springframework</groupId>
     48             <artifactId>spring-beans</artifactId>
     49             <version>${spring.version}</version>
     50         </dependency>
     51 
     52         <dependency>
     53             <groupId>org.springframework</groupId>
     54             <artifactId>spring-context</artifactId>
     55             <version>${spring.version}</version>
     56         </dependency>
     57 
     58         <dependency>
     59             <groupId>org.springframework</groupId>
     60             <artifactId>spring-tx</artifactId>
     61             <version>${spring.version}</version>
     62         </dependency>
     63 
     64         <dependency>
     65             <groupId>org.springframework</groupId>
     66             <artifactId>spring-web</artifactId>
     67             <version>${spring.version}</version>
     68         </dependency>
     69 
     70         <dependency>
     71             <groupId>org.springframework</groupId>
     72             <artifactId>spring-test</artifactId>
     73             <version>${spring.version}</version>
     74             <scope>test</scope>
     75         </dependency>
     76 
     77         <!-- 使用SpringMVC需配置 -->
     78         <dependency>
     79             <groupId>org.springframework</groupId>
     80             <artifactId>spring-webmvc</artifactId>
     81             <version>${spring.version}</version>
     82         </dependency>
     83         <!-- spring  cglib 代理 -->
     84         <dependency>
     85             <groupId>cglib</groupId>
     86             <artifactId>cglib</artifactId>
     87             <version>2.2.2</version>
     88         </dependency>
     89         <!-- 关系型数据库整合时需配置 如hibernate jpa等 -->
     90         <dependency>
     91             <groupId>org.springframework</groupId>
     92             <artifactId>spring-orm</artifactId>
     93             <version>${spring.version}</version>
     94         </dependency>
     95 
     96         <!-- hibernate -->
     97         <dependency>
     98             <groupId>org.hibernate</groupId>
     99             <artifactId>hibernate-core</artifactId>
    100             <version>${hibernate.version}</version>
    101         </dependency>
    102 
    103         <dependency>
    104             <groupId>org.hibernate</groupId>
    105             <artifactId>hibernate-ehcache</artifactId>
    106             <version>${hibernate.version}</version>
    107         </dependency>
    108 
    109         <!-- 二级缓存ehcache -->
    110         <dependency>
    111             <groupId>net.sf.ehcache</groupId>
    112             <artifactId>ehcache</artifactId>
    113             <version>2.9.0</version>
    114         </dependency>
    115 
    116         <!-- log4j -->
    117         <dependency>
    118             <groupId>log4j</groupId>
    119             <artifactId>log4j</artifactId>
    120             <version>1.2.17</version>
    121         </dependency>
    122 
    123         <!-- mysql连接 -->
    124         <dependency>
    125             <groupId>mysql</groupId>
    126             <artifactId>mysql-connector-java</artifactId>
    127             <version>5.1.34</version>
    128         </dependency>
    129 
    130         <!-- c3p0数据源 -->
    131         <dependency>
    132             <groupId>com.mchange</groupId>
    133             <artifactId>c3p0</artifactId>
    134             <version>0.9.5-pre10</version>
    135         </dependency>
    136 
    137         <!-- json -->
    138         <dependency>
    139             <groupId>com.alibaba</groupId>
    140             <artifactId>fastjson</artifactId>
    141             <version>1.2.3</version>
    142         </dependency>
    143 
    144         <dependency>
    145             <groupId>com.fasterxml.jackson.core</groupId>
    146             <artifactId>jackson-annotations</artifactId>
    147             <version>${jackson.version}</version>
    148         </dependency>
    149 
    150         <dependency>
    151             <groupId>com.fasterxml.jackson.core</groupId>
    152             <artifactId>jackson-core</artifactId>
    153             <version>${jackson.version}</version>
    154         </dependency>
    155 
    156         <dependency>
    157             <groupId>com.fasterxml.jackson.core</groupId>
    158             <artifactId>jackson-databind</artifactId>
    159             <version>${jackson.version}</version>
    160         </dependency>
    161 
    162         <!-- aop -->
    163         <dependency>
    164             <groupId>org.aspectj</groupId>
    165             <artifactId>aspectjweaver</artifactId>
    166             <version>1.8.4</version>
    167         </dependency>
    168 
    169         <!-- servlet -->
    170         <dependency>
    171             <groupId>javax.servlet</groupId>
    172             <artifactId>servlet-api</artifactId>
    173             <version>3.0-alpha-1</version>
    174             <scope>provided</scope>
    175         </dependency>
    176 
    177         <dependency>
    178             <groupId>javax.servlet</groupId>
    179             <artifactId>jstl</artifactId>
    180             <version>1.2</version>
    181         </dependency>
    182 
    183     </dependencies>
    184 </project>    
    View Code

    3.引入spring的配置信息,放在资源文件中

    路径下创建config.properties文件,这里面存放的就是一堆的变量,有关hibernate配置的变量

     1 #application configs
     2 
     3 #jdbc c3p0 config
     4 jdbc.driver = com.mysql.jdbc.Driver
     5 jdbc.url = jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf-8
     6 jdbc.username = root
     7 jdbc.password = root
     8 
     9 #hibernate config
    10 hibernate.dialect = org.hibernate.dialect.MySQLDialect
    11 hibernate.show_sql = true
    12 hibernate.format_sql = false
    13 hibernate.hbm2ddl.auto = update
    14 hibernate.cache.use_second_level_cache = true
    15 hibernate.cache.use_query_cache = true
    16 hibernate.cache.region.factory_class = org.hibernate.cache.ehcache.EhCacheRegionFactory
    17 hibernate.cache.provider_configuration_file_resource_path =ehcache.xml
    View Code

    4.引入Log4j日志文件配置

    下创建log4j.properties,

     1 ### set log levels ###
     2 log4j.rootLogger = INFO , C , D , E 
     3 
     4 ### console ###
     5 log4j.appender.C = org.apache.log4j.ConsoleAppender
     6 log4j.appender.C.Target = System.out
     7 log4j.appender.C.layout = org.apache.log4j.PatternLayout
     8 log4j.appender.C.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n
     9 
    10 ### log file ###
    11 log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
    12 log4j.appender.D.File = ../logs/springmvc_hibernate_demo.log
    13 log4j.appender.D.Append = true
    14 log4j.appender.D.Threshold = INFO 
    15 log4j.appender.D.layout = org.apache.log4j.PatternLayout
    16 log4j.appender.D.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n
    17 
    18 ### exception ###
    19 log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
    20 log4j.appender.E.File = ../logs/springmvc_hibernate_demo_error.log 
    21 log4j.appender.E.Append = true
    22 log4j.appender.E.Threshold = ERROR 
    23 log4j.appender.E.layout = org.apache.log4j.PatternLayout
    24 log4j.appender.E.layout.ConversionPattern =[sspringmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n
    View Code

    5.配置hibernate

    下创建spring-hibernate.xml,其中配置了数据源dataSource,配置sessionFactory,配置事务管理器。【如果需要连接多干服务器上的多个数据库,那就可以再多配一份同样的dataSource,sessionFacrory,事务管理器,在注入的时候,在Controller中,@Resource(注明是哪个sessionFactory即可)这里可能有误,之后再说】

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:tx="http://www.springframework.org/schema/tx"
     5     xmlns:aop="http://www.springframework.org/schema/aop"
     6     xmlns:context="http://www.springframework.org/schema/context"
     7     xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
     8         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
     9         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
    10         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd">
    11         
    12     <!-- 自动扫描@Controller注入为bean -->
    13     <context:property-placeholder location="classpath:config.properties"/>
    14     
    15         
    16     <!-- 配置数据源 c3p0 -->
    17     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
    18         destroy-method="close">
    19         <property name="driverClass" value="${jdbc.driver}" />
    20         <property name="jdbcUrl" value="${jdbc.url}" />
    21         <property name="user" value="${jdbc.username}" />
    22         <property name="password" value="${jdbc.password}" />
    23 
    24         <!-- 请求超时时间 -->
    25         <property name="checkoutTimeout" value="30000" />
    26         <!-- 每60秒检查所有连接池中的空闲连接。默认值: 0,不检查 -->
    27         <property name="idleConnectionTestPeriod" value="30" />
    28         <!-- 连接数据库连接池最大空闲时间 -->
    29         <property name="maxIdleTime" value="30" />
    30         <!-- 连接池初始化连接数 -->
    31         <property name="initialPoolSize" value="5" />
    32         <property name="minPoolSize" value="5" />
    33         <property name="maxPoolSize" value="20" />
    34         <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。默认值: 3 -->
    35         <property name="acquireIncrement" value="5" />
    36     </bean>
    37 
    38     <!-- 配置hibernate的SessionFactory -->
    39     <bean id="sessionFactory"
    40         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    41         <!-- 注入数据源 相关信息看源码 -->
    42         <property name="dataSource" ref="dataSource" />
    43         <!-- hibernate配置信息 -->
    44         <property name="hibernateProperties">
    45             <props>
    46                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
    47                 <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
    48                 <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
    49                 <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
    50 
    51                 <!-- 开启二级缓存 ehcache -->
    52                 <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
    53                 <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
    54                 <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
    55                 <prop key="hibernate.cache.provider_configuration_file_resource_path">${hibernate.cache.provider_configuration_file_resource_path}
    56                 </prop>
    57             </props>
    58         </property>
    59         <!-- 扫描hibernate注解配置的entity -->
    60         <property name="packagesToScan" value="com.it.entity" />
    61     </bean>
    62 
    63     <!-- 配置事务管理器 -->
    64     <bean id="transactionManager"
    65         class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    66         <property name="sessionFactory" ref="sessionFactory" />
    67     </bean>
    68 
    69     
    70     
    71     
    72     
    73 
    74 </beans>
    View Code

    6.配置ehcache.xml

    下创建ehcache.xml,配置的二级缓存

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
     3     <diskStore path="D:/ehcache" />
     4     <!-- DefaultCache setting. -->
     5      <defaultCache
     6             maxElementsInMemory="1000"
     7             eternal="false"
     8             timeToIdleSeconds="120"
     9             timeToLiveSeconds="120"
    10             maxElementsOnDisk="1000000"
    11             overflowToDisk="true" 
    12             memoryStoreEvictionPolicy="LRU">
    13             
    14     </defaultCache>
    15 
    16     <!-- Special objects setting. -->
    17 
    18     <cache 
    19          name="org.andy.work.entity.AcctUser"
    20          maxElementsInMemory="2"
    21          memoryStoreEvictionPolicy="LRU" 
    22          eternal="true" 
    23          diskPersistent="false"
    24          overflowToDisk="false" 
    25          maxElementsOnDisk="1000000" /> 
    26 
    27 
    28 
    29 </ehcache>
    View Code

    7.使用hibernate  tools生成实体

    在MyEcplise右上角,点击【如果没有,就点击MyEcplise Java Enterprise 左边的小图标】MyEcplise  Hibernate,进入

    在这里,New一个新的连接。连接到指定的数据库上

    编辑新的连接,下面的这些,必须完全一致,除了账号密码和驱动的路径,但是选择了驱动之后,Driver ClassName必须得是com.mysql.jdbc.Driver【如果是MySQL数据库的话】.

    编辑完成之后可以Test Driver一下看看是否可以连接成功。

    连接成功之后如下,我们就开始选择所有数据表,点击hibernate反转,生成entity

    但是此刻发现我们要选择的folder中不能指定到我们的项目中,我们的项目没有被识别出来。

    因此需要点击MyEcplise Jave Enterprise,回去设置我们的项目,让项目支持hibernate,或者说让项目变成hibernate项目

    右键项目 --->properties--->Project Facets

     完了之后会有两个自动生成的文件,看看是否需要留着,或者删除

     然后再回到hibernate tools下面

    这次就可以看到本项目了

    因为要使用注解的形式,所以,按照下面的选择,

    主键使用UUID,注意hibernate的版本的问题,需要注意选择的主键生成策略

     包下生成的实体如下:

     下面贴出来生成实体的代码:

    Authority.java

     1 package com.it.entity;
     2 
     3 import java.util.HashSet;
     4 import java.util.Set;
     5 import javax.persistence.CascadeType;
     6 import javax.persistence.Column;
     7 import javax.persistence.Entity;
     8 import javax.persistence.FetchType;
     9 import javax.persistence.GeneratedValue;
    10 import javax.persistence.Id;
    11 import javax.persistence.ManyToMany;
    12 import javax.persistence.Table;
    13 import org.hibernate.annotations.GenericGenerator;
    14 
    15 /**
    16  * Authority entity. @author MyEclipse Persistence Tools
    17  */
    18 @Entity
    19 @Table(name = "authority", catalog = "testdb")
    20 public class Authority implements java.io.Serializable {
    21 
    22     // Fields
    23 
    24     private String authorityId;
    25     private String authorityName;
    26     private Set<Role> roles = new HashSet<Role>(0);
    27 
    28     // Constructors
    29 
    30     /** default constructor */
    31     public Authority() {
    32     }
    33 
    34     /** full constructor */
    35     public Authority(String authorityName, Set<Role> roles) {
    36         this.authorityName = authorityName;
    37         this.roles = roles;
    38     }
    39 
    40     // Property accessors
    41     @GenericGenerator(name = "generator", strategy = "uuid.hex")
    42     @Id
    43     @GeneratedValue(generator = "generator")
    44     @Column(name = "authorityId", unique = true, nullable = false, length = 36)
    45     public String getAuthorityId() {
    46         return this.authorityId;
    47     }
    48 
    49     public void setAuthorityId(String authorityId) {
    50         this.authorityId = authorityId;
    51     }
    52 
    53     @Column(name = "authorityName", length = 50)
    54     public String getAuthorityName() {
    55         return this.authorityName;
    56     }
    57 
    58     public void setAuthorityName(String authorityName) {
    59         this.authorityName = authorityName;
    60     }
    61 
    62     @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "authorities")
    63     public Set<Role> getRoles() {
    64         return this.roles;
    65     }
    66 
    67     public void setRoles(Set<Role> roles) {
    68         this.roles = roles;
    69     }
    70 
    71 }
    View Code

    Myuser.java

      1 package com.it.entity;
      2 
      3 import java.sql.Timestamp;
      4 import java.util.HashSet;
      5 import java.util.Set;
      6 import javax.persistence.CascadeType;
      7 import javax.persistence.Column;
      8 import javax.persistence.Entity;
      9 import javax.persistence.FetchType;
     10 import javax.persistence.GeneratedValue;
     11 import javax.persistence.Id;
     12 import javax.persistence.ManyToMany;
     13 import javax.persistence.Table;
     14 import org.hibernate.annotations.GenericGenerator;
     15 
     16 /**
     17  * Myuser entity. @author MyEclipse Persistence Tools
     18  */
     19 @Entity
     20 @Table(name = "myuser", catalog = "testdb")
     21 public class Myuser implements java.io.Serializable {
     22 
     23     // Fields
     24 
     25     private String myUserId;
     26     private String myUserName;
     27     private String myUserPhone;
     28     private Timestamp myUserTime;
     29     private Set<Role> roles = new HashSet<Role>(0);
     30 
     31     // Constructors
     32 
     33     /** default constructor */
     34     public Myuser() {
     35     }
     36 
     37     /** minimal constructor */
     38     public Myuser(Timestamp myUserTime) {
     39         this.myUserTime = myUserTime;
     40     }
     41 
     42     /** full constructor */
     43     public Myuser(String myUserName, String myUserPhone, Timestamp myUserTime,
     44             Set<Role> roles) {
     45         this.myUserName = myUserName;
     46         this.myUserPhone = myUserPhone;
     47         this.myUserTime = myUserTime;
     48         this.roles = roles;
     49     }
     50 
     51     // Property accessors
     52     @GenericGenerator(name = "generator", strategy = "uuid.hex")
     53     @Id
     54     @GeneratedValue(generator = "generator")
     55     @Column(name = "myUserId", unique = true, nullable = false, length = 36)
     56     public String getMyUserId() {
     57         return this.myUserId;
     58     }
     59 
     60     public void setMyUserId(String myUserId) {
     61         this.myUserId = myUserId;
     62     }
     63 
     64     @Column(name = "myUserName", length = 20)
     65     public String getMyUserName() {
     66         return this.myUserName;
     67     }
     68 
     69     public void setMyUserName(String myUserName) {
     70         this.myUserName = myUserName;
     71     }
     72 
     73     @Column(name = "myUserPhone", length = 11)
     74     public String getMyUserPhone() {
     75         return this.myUserPhone;
     76     }
     77 
     78     public void setMyUserPhone(String myUserPhone) {
     79         this.myUserPhone = myUserPhone;
     80     }
     81 
     82     @Column(name = "myUserTime", nullable = false, length = 19)
     83     public Timestamp getMyUserTime() {
     84         return this.myUserTime;
     85     }
     86 
     87     public void setMyUserTime(Timestamp myUserTime) {
     88         this.myUserTime = myUserTime;
     89     }
     90 
     91     @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "myusers")
     92     public Set<Role> getRoles() {
     93         return this.roles;
     94     }
     95 
     96     public void setRoles(Set<Role> roles) {
     97         this.roles = roles;
     98     }
     99 
    100 }
    View Code

    Role.java

     1 package com.it.entity;
     2 
     3 import java.util.HashSet;
     4 import java.util.Set;
     5 import javax.persistence.CascadeType;
     6 import javax.persistence.Column;
     7 import javax.persistence.Entity;
     8 import javax.persistence.FetchType;
     9 import javax.persistence.GeneratedValue;
    10 import javax.persistence.Id;
    11 import javax.persistence.JoinColumn;
    12 import javax.persistence.JoinTable;
    13 import javax.persistence.ManyToMany;
    14 import javax.persistence.Table;
    15 import org.hibernate.annotations.GenericGenerator;
    16 
    17 /**
    18  * Role entity. @author MyEclipse Persistence Tools
    19  */
    20 @Entity
    21 @Table(name = "role", catalog = "testdb")
    22 public class Role implements java.io.Serializable {
    23 
    24     // Fields
    25 
    26     private String roleId;
    27     private String roleName;
    28     private Set<Myuser> myusers = new HashSet<Myuser>(0);
    29     private Set<Authority> authorities = new HashSet<Authority>(0);
    30 
    31     // Constructors
    32 
    33     /** default constructor */
    34     public Role() {
    35     }
    36 
    37     /** full constructor */
    38     public Role(String roleName, Set<Myuser> myusers, Set<Authority> authorities) {
    39         this.roleName = roleName;
    40         this.myusers = myusers;
    41         this.authorities = authorities;
    42     }
    43 
    44     // Property accessors
    45     @GenericGenerator(name = "generator", strategy = "uuid.hex")
    46     @Id
    47     @GeneratedValue(generator = "generator")
    48     @Column(name = "roleId", unique = true, nullable = false, length = 36)
    49     public String getRoleId() {
    50         return this.roleId;
    51     }
    52 
    53     public void setRoleId(String roleId) {
    54         this.roleId = roleId;
    55     }
    56 
    57     @Column(name = "roleName", length = 20)
    58     public String getRoleName() {
    59         return this.roleName;
    60     }
    61 
    62     public void setRoleName(String roleName) {
    63         this.roleName = roleName;
    64     }
    65 
    66     @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    67     @JoinTable(name = "userrole", catalog = "testdb", joinColumns = { @JoinColumn(name = "roleId", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "myUserId", nullable = false, updatable = false) })
    68     public Set<Myuser> getMyusers() {
    69         return this.myusers;
    70     }
    71 
    72     public void setMyusers(Set<Myuser> myusers) {
    73         this.myusers = myusers;
    74     }
    75 
    76     @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    77     @JoinTable(name = "roleauthor", catalog = "testdb", joinColumns = { @JoinColumn(name = "roleId", nullable = false, updatable = false) }, inverseJoinColumns = { @JoinColumn(name = "authorityId", nullable = false, updatable = false) })
    78     public Set<Authority> getAuthorities() {
    79         return this.authorities;
    80     }
    81 
    82     public void setAuthorities(Set<Authority> authorities) {
    83         this.authorities = authorities;
    84     }
    85 
    86 }
    View Code

    上面有几个需要注意的

         上面大多数都是Hibernate tools自动生成的,但是有几个需要手动添加:

                  1、如果这个实体使用二级缓存的话,需要添加@cache注解;

                  2、如果该实体里面还有集合元素(set, map,list),如果实体要采用二级缓存,那么这些集合元素必须也添加@cache注解

                  3、@JsonIgnoreProperties注解是为了防止SpringMVC在json返回时产生循环输出使用,如果不配置的话就会出现json死循环(还有多对多,一对多的属性时)。

                 4、@JsonIgnore这个是在转换成json是忽略该属性,而@JsonIgnoreProperties(value={"acctUsers", "acctAuthorities"})则是忽略acctRoles里面的acctUsers和acctAuthorites属性。

    8.创建Dao层、service层

    8.1 创建Dao层,面向接口的思想创建

    8.1.1  先要创建一个基础Dao

     1 package com.it.dao;
     2 
     3 import java.io.Serializable;
     4 import java.util.List;
     5 
     6 public interface GenericDao<T, PK extends Serializable> {
     7     
     8     T load(PK id);
     9     
    10     T get(PK id);
    11     
    12     List<T> findAll();
    13     
    14     void persist(T entity);
    15     
    16     PK save(T entity);
    17     
    18     void saveOrUpdate(T entity);
    19     
    20     void delete(PK id);
    21     
    22     void flush();
    23 }
    View Code

    8.1.2 再定义具体的接口,继承基础的Dao

     1 package com.it.dao;
     2 
     3 import com.it.entity.Myuser;
     4 
     5 /**
     6  * MyUser的Dao
     7  * @author Administrator
     8  *
     9  */
    10 public interface MyUserDao extends GenericDao<Myuser, String> {
    11     
    12 }
    View Code

    8.1.3 接着定义具体的DaoImpl的实现类

     1 package com.it.dao.Impl;
     2 
     3 import java.util.List;
     4 
     5 
     6 import org.hibernate.Session;
     7 import org.hibernate.SessionFactory;
     8 import org.springframework.beans.factory.annotation.Autowired;
     9 import org.springframework.stereotype.Repository;
    10 
    11 import com.it.dao.MyUserDao;
    12 import com.it.entity.Myuser;
    13 
    14 
    15 @Repository("myUserDao")
    16 public class MyUserDaoImpl implements MyUserDao {
    17     
    18     @Autowired
    19     private SessionFactory sessionFactory;
    20     
    21     
    22     private Session getCurrentSession() {
    23         return this.sessionFactory.getCurrentSession();
    24     }
    25 
    26     public Myuser load(String id) {
    27         // TODO Auto-generated method stub
    28         return (Myuser) this.getCurrentSession().load(Myuser.class, id);
    29     }
    30 
    31     public Myuser get(String id) {
    32         // TODO Auto-generated method stub
    33         return (Myuser) this.getCurrentSession().get(Myuser.class, id);
    34     }
    35 
    36     public List<Myuser> findAll() {
    37         @SuppressWarnings("unchecked")
    38         List<Myuser> allUser = this.getCurrentSession().createQuery("from Myuser").list();
    39         return allUser;
    40     }
    41 
    42     public void persist(Myuser entity) {
    43         this.getCurrentSession().persist(entity);
    44     }
    45 
    46     /**
    47      * 可以选择手动控制事务的提交,也可以交给spring自动去提交
    48      */
    49     public String save(Myuser entity) {
    50         // TODO Auto-generated method stub
    51 //        Session session = sessionFactory.openSession();
    52 //        session.getTransaction().begin();
    53 //        session.;
    54 //        session.getTransaction().commit();
    55 //        session.flush();
    56 //        session.close();
    57         return (String) this.getCurrentSession().save(entity);
    58     }
    59 
    60     public void saveOrUpdate(Myuser entity) {
    61         // TODO Auto-generated method stub
    62          this.getCurrentSession().saveOrUpdate(entity);
    63     }
    64 
    65     public void delete(String id) {
    66         // TODO Auto-generated method stub
    67         Myuser myuser=this.load(id);
    68         this.getCurrentSession().delete(myuser);
    69     }
    70 
    71     public void flush() {
    72         this.getCurrentSession().flush();
    73     }
    74 
    75 }
    View Code

    8.2 创建service层,也是面向接口的思想创建

    8.2.1 创建一个基础Service

     1 package com.it.service;
     2 
     3 import java.io.Serializable;
     4 import java.util.List;
     5 
     6 public interface GenericService<T, PK extends Serializable> {
     7     
     8     T load(PK id);
     9     
    10     T get(PK id);
    11     
    12     List<T> findAll();
    13     
    14     void persist(T entity);
    15     
    16     PK save(T entity);
    17     
    18     void saveOrUpdate(T entity);
    19     
    20     void delete(PK id);
    21     
    22     void flush();
    23 }
    View Code

    8.2.2 创建service继承基础的Service

    1 package com.it.service;
    2 
    3 import com.it.entity.Myuser;
    4 
    5 public interface MyUserService extends GenericService<Myuser, String> {
    6 
    7 }
    View Code

    8.2.3 创建serviceImpl

     1 package com.it.service.Impl;
     2 
     3 import java.util.List;
     4 
     5 import javax.annotation.Resource;
     6 
     7 import org.springframework.beans.factory.annotation.Autowired;
     8 import org.springframework.stereotype.Service;
     9 import org.springframework.transaction.annotation.Transactional;
    10 
    11 import com.it.dao.MyUserDao;
    12 import com.it.entity.Myuser;
    13 import com.it.service.GenericService;
    14 import com.it.service.MyUserService;
    15 
    16 
    17 @Service("myUserService")
    18 @Transactional
    19 public class MyUserServiceImpl implements MyUserService {
    20     
    21     @Resource(name = "myUserDao")
    22     private MyUserDao myUserDao;
    23     
    24 
    25     public Myuser load(String id) {
    26         // TODO Auto-generated method stub
    27         return myUserDao.load(id);
    28     }
    29 
    30     public Myuser get(String id) {
    31         // TODO Auto-generated method stub
    32         return myUserDao.get(id);
    33     }
    34 
    35     public List<Myuser> findAll() {
    36         // TODO Auto-generated method stub
    37         return myUserDao.findAll();
    38     }
    39 
    40     public void persist(Myuser entity) {
    41         // TODO Auto-generated method stub
    42         myUserDao.persist(entity);
    43     }
    44     
    45     public String save(Myuser entity) {
    46         // TODO Auto-generated method stub
    47         return myUserDao.save(entity);
    48     }
    49 
    50     public void saveOrUpdate(Myuser entity) {
    51         // TODO Auto-generated method stub
    52         myUserDao.saveOrUpdate(entity);
    53     }
    54 
    55     public void delete(String id) {
    56         // TODO Auto-generated method stub
    57         myUserDao.delete(id);
    58     }
    59 
    60     public void flush() {
    61         // TODO Auto-generated method stub
    62         myUserDao.flush();
    63     }
    64 
    65 }
    View Code

    9.配置spring-mvc.xml

    spring-mvc.xml中配置了自动扫描Controller层注解+视图解析器

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:mvc="http://www.springframework.org/schema/mvc"
     4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     5     xmlns:p="http://www.springframework.org/schema/p"
     6     xmlns:context="http://www.springframework.org/schema/context"
     7     xmlns:tx="http://www.springframework.org/schema/tx"
     8     xmlns:aop="http://www.springframework.org/schema/aop"
     9     xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
    10         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
    11         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
    12         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
    13         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
    14 
    15     <!-- 自动扫描@Controller注入为bean -->
    16     <context:component-scan base-package="com.it" >
    17     
    18     </context:component-scan>
    19     <!-- 标明注解事务 -->
    20     <tx:annotation-driven transaction-manager="transactionManager" />
    21     
    22     <!-- 以下为SpringMVC配置 -->
    23     <mvc:annotation-driven>
    24         <!-- 返回json数据,@response使用 -->
    25         <mvc:message-converters register-defaults="true">
    26             <bean
    27                 class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
    28                 <property name="supportedMediaTypes">
    29                     <list>
    30                         <value>text/html;charset=UTF-8</value>
    31                         <value>application/json;charset=UTF-8</value>
    32                     </list>
    33                 </property>
    34 
    35             </bean>
    36         </mvc:message-converters>
    37     </mvc:annotation-driven>
    38 
    39     <!-- 对模型视图名称的解析,即在模型视图名称添加前后缀 -->
    40     <bean
    41         class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    42         <property name="viewClass"
    43             value="org.springframework.web.servlet.view.JstlView" />
    44         <property name="prefix" value="/WEB-INF/views" />
    45         <property name="suffix" value=".jsp" />
    46     </bean>
    47     
    48     <!-- 下面设置配置事物以及事务管理,是一种事务的处理方式,还可以有另一种 就是不写下面这一大块,直接在service层添加@Transactional
    49     解释一下这两种的区别:
    50     1.@Transactional  在serviceImpl层使用这个注解,表示默认的事务都是propagation="REQUIRED",这样不会有下面read-only这一项了,那么比如在查询的时候只要保证这个查询是在一个事务中,将结果查询出来,对这个对象进行修改,不用调用save等方法,事务会自动帮你进行持久化的操作,会将你这个操作保存在数据库中
    51     2.使用下面的这两个事务管理,可以自己配置什么方法什么操作【insert、get】,可以自己设置事务的类型,也可以设置read-only。设置了read-only的话,在从数据库中查询出一条记录,对对象进行更改,那就必须调用save或者update方法才能进行保存
    52     
    53     
    54      配置事务增强处理Bean,指定事务管理器   意思是这个id为transactionAdvice的事务(建议),他的事务管理者是上面指定的id为transactionManager的事务管理器
    55     <tx:advice id="transactionAdvice" transaction-manager="transactionManager" >
    56         配置详细事务处理语义
    57         <tx:attributes>
    58             在指定的如下的这些操作发生时,例如insert插入数据发生时,事务类型的request ,而get等操作,事务类型是supports,并且是只读
    59             <tx:method name="insert*" propagation="REQUIRED" />
    60             <tx:method name="update*" propagation="REQUIRED" />
    61             <tx:method name="delete*" propagation="REQUIRED" />
    62 
    63             <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
    64             <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
    65             <tx:method name="select*" propagation="SUPPORTS" read-only="true" />
    66             <tx:method name="load*" propagation="SUPPORTS" read-only="true" />
    67 
    68             其他采用默认事务方式
    69             <tx:method name="*"  propagation="REQUIRED" />
    70             
    71         </tx:attributes>
    72     </tx:advice>
    73 
    74     Spring aop事务管理  
    75     <aop:config proxy-target-class="true">
    76         配置切入点    指定这个aop:pointcut去引用上面规定的advice,也就是说规定下面的这个expression指定的路径下的service.impl下的所有的方法,都按照上面advice中的规定去执行,碰上什么操作,事务就是什么类型的,这就是事务管理器的好处了
    77         解释一下,为什么这个要指定在service层:因为在同一个事务中,可能要对多张表进行多个不同的操作,才是一个完整的逻辑,例如淘宝上买东西,你转账之后你的钱减少了,对方的钱应该增加了,这两个操作在一起才是一个完整的操作,而如果这两个操作不在一个事务中,也就是如果将事务的操作指定在Dao层【MVC的设计模式:Dao层就是对数据库进行最简单的增删改查操作,而service层是进行逻辑处理的,一个完整的逻辑处理就要涉及到多次操作】事务操作失败,发生回滚,那你的帐减少了,对方的帐并没有增加,这样就不美丽的,因此,将事务的管理,指定在了service层
    78         <aop:pointcut id="transactionPointcut"
    79             expression="execution(* com.it.service..*Impl.*(..))" />expression中表达式所指意思: 所有的文件下的 com.it.service开头的包,以Impl结尾的类下的所有的方法,都执行上面advice的规定 
    80         指定在txAdvice切入点应用txAdvice事务增强处理
    81         <aop:advisor pointcut-ref="transactionPointcut"
    82             advice-ref="transactionAdvice" />
    83     </aop:config> -->
    84     
    85 </beans>
    View Code

    10.配置web.xml容器

     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     3     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
     4     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
     5     id="WebApp_ID" version="2.5">
     6 <!-- web容器是web项目的大脑 -->
     7 <!-- 在web.xml中,执行顺序是:1.先执行listener 2。再执行filter  3.最后执行servlet 这就是执行顺序 
     8     就像spring-hibernate.xml文件是在执行Listener的时候加载的,那注意这几个配置文件在web.xml中的加载顺序,因为资源文件是在配置文件【xml文件】中加载的,肯定是先加载的资源文件【properties文件】,才能在配置文件中调用资源文件中的变量的值使用
     9 
    10  -->
    11     <display-name>springmvc_demo</display-name>
    12 <!-- web容器,首先需要引入spring,让spring管理各个框架,并将其注入为bean -->
    13 <!-- 这个相当于定一个 变量在web.xml中,在下面的listener  org.springframework.web.context.ContextLoaderListener中,加载这个spring-hibernate.xml文件 -->
    14     <context-param>
    15         <param-name>contextConfigLocation</param-name>
    16         <param-value>classpath:spring-hibernate.xml</param-value>
    17     </context-param>
    18 <!-- 配置控制层的filter信息 -->
    19     <filter>
    20         <filter-name>encodingFilter</filter-name>
    21         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    22         <init-param>
    23             <param-name>encoding</param-name>
    24             <param-value>utf-8</param-value>
    25         </init-param>
    26         <init-param>
    27             <param-name>forceEncoding</param-name>
    28             <param-value>true</param-value>
    29         </init-param>
    30     </filter>
    31     <filter-mapping>
    32         <filter-name>encodingFilter</filter-name>
    33         <url-pattern>/*</url-pattern>
    34     </filter-mapping>
    35 
    36     <!-- openSessionInView配置 作用是延迟session关闭到view层 -->
    37     <filter>
    38         <filter-name>openSessionInViewFilter</filter-name>
    39         <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
    40         <init-param>
    41             <param-name>singleSession</param-name>
    42             <param-value>true</param-value>
    43         </init-param>
    44     </filter>
    45 
    46 <!-- 监听servletContext,启动contextConfigLocation中的spring配置信息 -->
    47     <listener>
    48         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    49     </listener>
    50 
    51 
    52     <!-- 防止spring内存溢出监听器   可用可不用-->
    53     <listener>
    54         <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    55     </listener>
    56 
    57 
    58 <!-- 类似与servlet 需要在web.xml中都需要配置一样,spring的思想是让这些servlet【controller也是servlet】继承了一个基础的servlet,那就只需在web.xml中配置一个servlet即可。 -->
    59 <!-- 这个servlet和下面的servlet-mapping相配合使用,注明了所有的以.htmls结尾的请求都被截取到,去到servlet中去找相对应的方法 进行处理 -->
    60     <servlet>
    61         <description>spring mvc servlet</description>
    62         <servlet-name>rest</servlet-name>
    63         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    64         <init-param>
    65             <param-name>contextConfigLocation</param-name>
    66             <!-- 此处配置的是SpringMVC的配置文件 -->
    67             <param-value>classpath:spring-mvc.xml</param-value>
    68         </init-param>
    69         <load-on-startup>1</load-on-startup>
    70     </servlet>
    71     <!-- 配置了springmvc拦截的url为以.hmls结尾的请求 -->
    72     <servlet-mapping>
    73         <servlet-name>rest</servlet-name>
    74         <url-pattern>*.htmls</url-pattern>
    75     </servlet-mapping>
    76 
    77     <filter-mapping>
    78         <filter-name>openSessionInViewFilter</filter-name>
    79         <url-pattern>/*</url-pattern>
    80     </filter-mapping>
    81 
    82     <!-- 配置session超时时间,单位分钟 -->
    83     <session-config>
    84         <session-timeout>30</session-timeout>
    85     </session-config>
    86     <!-- 欢迎界面 默认的项目访问界面 -->
    87     <welcome-file-list>
    88         <welcome-file>/index.jsp</welcome-file>
    89     </welcome-file-list>
    90 </web-app>
    View Code

    11.创建Controller层

     

     1 package com.it.controller;
     2 
     3 import java.sql.Timestamp;
     4 import java.util.List;
     5 import java.util.UUID;
     6 
     7 import javax.annotation.Resource;
     8 
     9 import org.apache.log4j.Logger;
    10 import org.springframework.stereotype.Controller;
    11 import org.springframework.ui.ModelMap;
    12 import org.springframework.web.bind.annotation.PathVariable;
    13 import org.springframework.web.bind.annotation.RequestMapping;
    14 import org.springframework.web.bind.annotation.ResponseBody;
    15 
    16 import com.it.entity.Myuser;
    17 import com.it.service.MyUserService;
    18 
    19 
    20 
    21 
    22 @Controller
    23 @RequestMapping("/myuser")
    24 public class MyUserController {
    25     
    26     private static final Logger LOGGER = Logger.getLogger(MyUserController.class);
    27     
    28     
    29     @Resource( name = "myUserService")
    30     private MyUserService  myUserService;
    31     
    32     
    33     @RequestMapping("/saveOne")
    34     public String saveOne(){
    35         Myuser myuser = new Myuser();
    36         //myuser.setMyUserId(UUID.randomUUID().toString());
    37         myuser.setMyUserName("andy");
    38         myuser.setMyUserPhone("13823237878");
    39         myuser.setMyUserTime(Timestamp.valueOf("1995-09-15 12:12:12"));
    40         myUserService.save(myuser);
    41         return "/user/showInfo";
    42     }
    43     
    44     @RequestMapping("/showInfo/{userId}")
    45     public String showUserInfo(ModelMap model, @PathVariable String userId){
    46         LOGGER.info("查询用户:"+userId);
    47         Myuser myuser = myUserService.load(userId);
    48         model.addAttribute("userInfo", myuser);
    49         return "/user/showInfo";
    50     }
    51     
    52     
    53     @RequestMapping("/showInfos")
    54     public @ResponseBody List<Myuser> showAllUser(){
    55         LOGGER.info("查询所有用户");
    56         List<Myuser> list = myUserService.findAll();
    57         return list;
    58     }
    59 }
    View Code

    12.创建view视图层

    在src/main/webapp/WEB-INF/views下 创建user/showInfo.jsp

     1 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
     2 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
     3 <%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
     4 
     5 <%
     6     String path = request.getContextPath();
     7     String basePath = request.getScheme() + "://"
     8             + request.getServerName() + ":" + request.getServerPort()
     9             + path + "/";
    10 %>
    11 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    12 <html>
    13 <head>
    14 <base href="<%=basePath%>" />
    15 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    16 <script type="text/javascript" src="js/jquery-1.9.1.min.js"></script>
    17 <title>用户信息展示</title>
    18 </head>
    19 <body>
    20     用户信息 昵称: ${userInfo.myUserName} 用户id:${userInfo.myUserId} 用户电话:${userInfo.myUserPhone } 注册时间:
    21     <fmt:formatDate value="${userInfo.myUserTime }" pattern="yyyy-MM-dd HH:mm:ss" />
    22     角色:[
    23     <c:forEach items="${ userInfo.roles}" var="role">
    24                         ${role.roleName }   权限[
    25                            <c:forEach items="${ role.authorities}" var="authority">
    26                              ${authority.authorityName } 
    27                            </c:forEach> ]
    28                       </c:forEach>
    29     ]
    30 
    31     <br /> ajax显示全部用户信息:
    32     <div id="show_all_user"></div>
    33 </body>
    34 <script type="text/javascript">
    35     $.ajax({
    36         type : "get",
    37         url : "myuser/showInfos.htmls",
    38         dataType : "json",
    39         success : function(data) {
    40             $(data).each(
    41                     function(i, user) {
    42                         var p = "<p>昵称:" + user.myUserName + "    电话:"
    43                                 + user.myUserPhone + "    注册时间:"
    44                                 + user.myUserTime + "    id:" + user.myUserId +
    45                         "</p>";
    46                         $("#show_all_user").append(p);
    47                     });
    48         },
    49         async : true
    50     });
    51 </script>
    52 </html>
    View Code

     13. 一切准备就绪,把项目部署到tomcat中,启动即可

    可能你会说,那要这个view页面做什么??因为参考别人的嘛 并且,这个页面比较值得钻研

  • 相关阅读:
    kafka学习笔记:知识点整理
    ZooKeeper基本原理
    Channel详解
    redis十-对快照模式分析
    文字两行显示
    vue 脚手架创建新项目时报错 ERROR Failed to get response from http://registry.cnpmjs.org/vue-cli-version
    checkbox 点选后没有被选中,有点击事件,不显示小勾
    git 提示 没有操作权限
    HBuilder X 提示Setting.json格式语法错误
    格式化代码时提示错误
  • 原文地址:https://www.cnblogs.com/sxdcgaq8080/p/5606827.html
Copyright © 2011-2022 走看看