swiftR

使用maven来构建项目

pom.xml

pom依赖如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
<dependencies>
   <!-- SpringMVC -->
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-webmvc</artifactId>
     <version>5.0.11.RELEASE</version>
   </dependency>

   <!-- Spring JDBC -->
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-jdbc</artifactId>
     <version>5.0.11.RELEASE</version>
   </dependency>

   <!-- Spring AOP -->
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aop</artifactId>
     <version>5.0.11.RELEASE</version>
   </dependency>
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aspects</artifactId>
     <version>5.0.11.RELEASE</version>
   </dependency>

   <!-- MyBatis -->
   <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis</artifactId>
     <version>3.4.5</version>
   </dependency>

   <!-- MyBatis整合Spring -->
   <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis-spring</artifactId>
     <version>1.3.1</version>
   </dependency>

   <!-- MySQL驱动 -->
   <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.11</version>
   </dependency>

   <!-- C3P0 -->
   <dependency>
     <groupId>c3p0</groupId>
     <artifactId>c3p0</artifactId>
     <version>0.9.1.2</version>
   </dependency>

   <!-- JSTL -->
   <dependency>
     <groupId>jstl</groupId>
     <artifactId>jstl</artifactId>
     <version>1.2</version>
   </dependency>

   <!-- ServletAPI -->
   <dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>javax.servlet-api</artifactId>
     <version>3.1.0</version>
   </dependency>

   <dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
     <version>1.18.6</version>
     <scope>provided</scope>
   </dependency>
 </dependencies>

接下来是spring容器的初始化，加载springmvc来初始化webApplicationContext，传统方式都是在web.xml中配置初始化dispatcherServerlet 

1
2
3
4
5
6
7
8
9
<!-- SpringMVC的前端控制器，拦截所有请求  -->
<!--<servlet>-->
    <!--<servlet-name>mvc-dispatcher</servlet-name>-->
    <!--<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>-->
    <!--<init-param>-->
        <!--<param-name>contextConfigLocation</param-name>-->
        <!--<param-value>classpath:springmvc.xml</param-value>-->
    <!--</init-param>-->
<!--</servlet>-->

现在通过实现WebApplicationInitializer接口来完成

1
2
3
4
在Spring-web项目中有类SpringServletContainerInitializer，它实现了Servlet3.0的ServletContainerInitializer接口，且优先级会高于xml中配置的listener。在SpringServletContainerInitializer中有注解@HandlesTypes(WebApplicationInitializer.class)，具体如下：

因为这个类声明了HandlesTypes，并指定了类型为WebApplicationInitializer.class，在Servlet3.0+中web容器启动时，会扫描类路径下所有的WebApplicationInitializer接口实现类，并提供一个set集合给onStartup方法执行。
onStartup方法执行时，会遍历该set，并使用newInstance()方式进行实例化，实例化后依据@Order注解进行排序，最后在依次调用onStartup(ServletContext)方法，完成初始化。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class MyWebApplicationInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // Load Spring web application configuration
        AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext();
        ac.register(AppConfig.class);

        ac.refresh();


        // Create and register the DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(ac);
//        servlet.setContextConfigLocation();



        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
        registration.setLoadOnStartup(1);
        System.out.println("init end");


        registration.addMapping("/*");
    }
}

治理就直接同过AnnotationConfigWebApplicationContext()来完成容器的初始化，通过AppConfig这个类完成配置

AppConfig.java

1
2
3
4
5
6
@Configuration
@PropertySource("classpath:application.properties")
@ComponentScan("cn.lzl")
@EnableAspectJAutoProxy
@Import(LoggerAspect.class)
public class AppConfig {

springmvc的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
@Configuration
public class MvcConfig {


    @Bean
    public InternalResourceViewResolver internalResourceViewResolver(){
        InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();
        internalResourceViewResolver.setPrefix("/");
        internalResourceViewResolver.setSuffix("jsp");
        System.out.println("end");
        return internalResourceViewResolver;
    }

//    @Bean
//    public CommonsMultipartResolver multipartResolver(){
//        CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver();
//        commonsMultipartResolver.setDefaultEncoding("utf-8");
//        commonsMultipartResolver.setMaxUploadSizePerFile(1231214);
//        commonsMultipartResolver.setMaxUploadSize(124143242);
//        return commonsMultipartResolver;
//    }

    @Bean(name = "multipartResolver")
    public MultipartResolver multipartResolver(){
        CommonsMultipartResolver resolver = new CommonsMultipartResolver();
        resolver.setDefaultEncoding("UTF-8");
        resolver.setResolveLazily(true);//resolveLazily属性启用是为了推迟文件解析，以在在UploadAction中捕获文件大小异常
        resolver.setMaxInMemorySize(40960);
        resolver.setMaxUploadSize(50*1024*1024);//上传文件大小 50M 50*1024*1024
        return resolver;
    }
}

mybatis的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
@Configuration
public class MybatisConfig {


//配置MyBatis SqlSessionFactory
    @Bean
    public SqlSessionFactory sqlSessionFactory(ApplicationContext applicationContext) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource());
        factoryBean.setConfigLocation(applicationContext.getResource("classpath:mybatis-config.xml"));
//        factoryBean.setMapperLocations(new Resource[]{applicationContext.getResource("classpath:mapper/*.xml")});
        return factoryBean.getObject();
    }
    
    //配置数据源,可以使用连接池

    @Bean
    public DataSource dataSource(){
        PooledDataSource pooledDataSource = new PooledDataSource();
        pooledDataSource.setUsername("root");
        pooledDataSource.setPassword("123456");
        pooledDataSource.setUrl("jdbc:mysql://localhost:3306/test");
        pooledDataSource.setDriver("com.mysql.cj.jdbc.Driver");
        return pooledDataSource;
    }

    /**
     * mapper扫描,扫描mapper接口，并生成bean
     * @return
     */
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setBasePackage("cn.lzl.mybatis");
        return mapperScannerConfigurer;
    }

}

mybatis-config.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">



<configuration>

    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
        <!-- 开启二级缓存 -->
        <setting name="cacheEnabled" value="true"/>
    </settings>

    <typeAliases>
        <typeAlias alias="User" type="cn.lzl.mybatis.User"/>
    </typeAliases>

    <!--&lt;!&ndash; mybatis-config.xml &ndash;&gt;-->
    <typeHandlers>
        <typeHandler handler="cn.lzl.mybatis.ExampleHandler"/>
    </typeHandlers>



    <!--<environments default="development">-->
        <!--<environment id="development">-->
            <!--<transactionManager type="JDBC"/>-->
            <!--<dataSource type="POOLED">-->
                <!--<property name="driver" value="com.mysql.cj.jdbc.Driver" />-->
                <!--<property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=false&amp;characterEncoding=UTF-8" />-->
                <!--<property name="username" value="root" />-->
                <!--<property name="password" value="123456" />-->
            <!--</dataSource>-->
        <!--</environment>-->
    <!--</environments>-->

    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>



</configuration>

Usermapper.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.lzl.mybatis.UserMapper">
    <cache></cache>

    <select id="selectUser" resultType="User">
    select * from t_user limit 1
  </select>

    <select id="selectUserById" resultType="User">
        select * from t_user where id = #{id}
    </select>
</mapper>

一个简单的测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Controller
public class Test {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @GetMapping(value = "/test",produces = "text/html;charset=UTF-8")
    public String test(String id,HttpServletRequest request) {
//        System.out.println(sqlSessionFactory.getConfiguration());
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        System.out.println(sqlSession.getMapper(UserMapper.class).selectUser());
        System.out.println(userMapper.selectUserById("1"));
        request.getParameter("id");

        System.out.println("-------------");
        System.out.println(userMapper.selectUser());
        System.out.println("-----------");

        return "test";
    }
 Previous