标签：spring

spring_mvc_mybatis傻瓜入门篇之二spring与spring-mvc

上篇我们已经弄好了spring 与mybatis，即搞定了数据model层的东西，已经可以对外提供数据服务了，那么现在就要将spring-mvc加上去，增加逻辑与展示！

一.增加依赖包

在pom.xml中增加配置项

 <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-webmvc</artifactId>  
        <version>${spring.version}</version>  
    </dependency>

增加spring_mvc 的配置文件（servlet-context.xml）如下

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
		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">

	<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
	
	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />

	<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
	<resources mapping="/resources/**" location="/resources/" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
	<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>
	
	<!-- SpringMVC上传文件时，需要配置MultipartResolver处理器 -->
	<beans:bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<beans:property name="defaultEncoding" value="utf-8" />
		<beans:property name="maxUploadSize" value="10485760000" />
		<beans:property name="maxInMemorySize" value="40960" />
	</beans:bean>
    
	<context:component-scan base-package="com.test.controller" />
	
</beans:beans>

将该 配置文件路径添加到web.xml上：

<!-- Processes application requests -->
	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/spring/appServlet/servlet-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
		
	<servlet-mapping>
		<servlet-name>appServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

配置好了，然后就可以开始新建个页面测试下了

新建展示页面showUserInfo.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
${userinfo.name}：${userinfo.passwd}
</body>
</html>

新建逻辑控制页面代码：

package com.test.controller;

import javax.annotation.Resource;  
import javax.servlet.http.HttpServletRequest;  
import org.springframework.stereotype.Controller;  
import org.springframework.ui.Model;  
import org.springframework.web.bind.annotation.RequestMapping;  
import com.test.model.UserInfo;  
import com.test.service.IUserInfoService;  


@Controller  
@RequestMapping("/user") 
public class queryUserController {

	 @Resource  
	 private IUserInfoService userService;  
	  
	    @RequestMapping("/showUserInfo")  
	    public String toIndex(HttpServletRequest request, Model model) {  
	        long pos_int = Long.parseLong(request.getParameter("id"));  
	        UserInfo userinfo = this.userService.getUserInfoById(pos_int);  
	        model.addAttribute("userinfo", userinfo);  
	        return "showUserInfo"; 
	    }
}

好了，就可以运行调试：http://localhost:8080/smvc/user/showUserInfo?id=1

QA:

有很大几率你是不能一次性就运行成功的，会报很多错误，那么耐性看他报错信息，然后找谷歌问一问你就可以得到答案！当然如果你怕麻烦，那么也可以预先做下如下处理以避免各种报错：

1.在项目属性中，添加如下图红框中的路径配置

image

其他的一时也记不起来了，出问题了百度吧，或者留言！

spring_mvc_mybatis傻瓜入门篇之spring与mybatis

  • 一.介绍

  • spring

  • 目前编程，一般我们都会在一个框架一下进行编程，而目前J2EE比较流行的框架，SPRING 当居其首。当然我们可以先撇开JAVA,撇开SPRING，一般进行编程都会运用到GOF中设计模式思想使得我们的代码程序可读可扩展解耦等等，那么在设计框架的时候，不管啥语言啥框架，他的中心思想就是屏蔽细节让我们用起来简单方便，实现这个目标有很多方式，那么作为GOD设计模式的延伸，一般的服务框架目前都已经运用IOC->AOP->SOA思想进行框架的设计实现！最基础的是 IOC，在此基础上实现AOP,SOA！关于其中的关系传送门在此！SPIRNG只是众多框架中的一种，但好用方便，所以用户众多！

  • SPRING_MVC

  • MVC是一种3层设计模式，web mvc 顾名思义就是web端的mvc,SPRING_MVC是对MVC的一种web实现！

  • Mybatis

  • mybaits封装了后台与数据库持久层的一个框架！

相互关系

spring作为核心可以自由的与各种持久层框架，web框架组合出不同的架构，如ssh(web框架struct,持久层框架hiberante)等！所以其他都可换，核心 spring 就不要换了，一个好的芯还是很重要的! 今天要入门的就是 spring + spring-mvc+mybatis

二.工具安装

工欲善其事必先利其器，spring 的开发都会有一个 sts的套件，其实 就是帮你安装好方便使用spring 相关插件的 eclipse ！那就下载过来安装起来就好了！

三.创建项目

我们项目使用maven 管理，如果你还不知道maven ,那么找wikipedia 详细了解下，如果你只想知道在eclipse下的安装使用，那么这里你可以快速入门。 安装好之后之后，就可以建立maven工程，按说明next你就成功了：

image

通过pom.xml 配置文件引入各种需要的jar包具体看下面各个模块的需要引入！一般我们会引入日志，所以再配置下日志的配置文件如下（log4j.xml）：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appenders -->
	<appender name="console" class="org.apache.log4j.ConsoleAppender">
		<param name="Target" value="System.out" />
		<layout class="org.apache.log4j.PatternLayout">
			<param name="ConversionPattern" value="%-5p: %c - %m%n" />
		</layout>
	</appender>
	
	<!-- Application Loggers -->
	<logger name="com.hundsun.smvc">
		<level value="info" />
	</logger>
	
	<!-- 3rdparty Loggers -->
	<logger name="org.springframework.core">
		<level value="info" />
	</logger>
	
	<logger name="org.springframework.beans">
		<level value="info" />
	</logger>
	
	<logger name="org.springframework.context">
		<level value="info" />
	</logger>

	<logger name="org.springframework.web">
		<level value="info" />
	</logger>

	<!-- Root Logger -->
	<root>
		<priority value="warn" />
		<appender-ref ref="console" />
	</root>
	
</log4j:configuration>

四 .spring

spring 框架只需要在 pom.xml上配置引入spring 的jar,如下

<?xml version="1.0" encoding="UTF-8"?>
<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.hundsun</groupId>
	<artifactId>smvc</artifactId>
	<name>smvc</name>
	<packaging>war</packaging>
	<version>1.0.0-BUILD-SNAPSHOT</version>
	<properties>
		<java-version>1.6</java-version>
		<org.springframework-version>4.2.0.RELEASE</org.springframework-version>
		<org.aspectj-version>1.6.10</org.aspectj-version>
		<org.slf4j-version>1.6.6</org.slf4j-version>
	</properties>
	<dependencies>
	<!-- Spring -->
	<!-- spring核心包 -->  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-core</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-web</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-oxm</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-tx</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-jdbc</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-webmvc</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-aop</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-context-support</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
  
    <dependency>  
        <groupId>org.springframework</groupId>  
        <artifactId>spring-test</artifactId>  
        <version>${org.springframework-version}</version>  
    </dependency>  
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${org.springframework-version}</version>
			<exclusions>
				<!-- Exclude Commons Logging in favor of SLF4j -->
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				 </exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>

	</dependencies>
</project>

五.在Spring中加入mybatis

先在pom.xml配置上mybatis 用到的引入包信息

<!-- jackson 包 -->
    <dependency>  
        <groupId>org.codehaus.jackson</groupId>  
        <artifactId>jackson-mapper-asl</artifactId>  
        <version>1.9.13</version>  
    </dependency>
		
		<!-- mybatis 包 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.8</version>
		</dependency>

		<!--mybatis spring 插件 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.2</version>
		</dependency>
		
		<!-- mysql连接 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.34</version>
		</dependency>
		
		<!-- dbcp的jar包，用来在applicationContext.xml中配置数据库 -->  
   		<dependency>  
           <groupId>commons-dbcp</groupId>  
           <artifactId>commons-dbcp</artifactId>  
           <version>1.2.2</version>  
   		</dependency>

配置jdbc 配置文件 （jdbc.properties）

url=jdbc:mysql://115.29.151.158:3306/mytrade?useUnicode=true&characterEncoding=utf8 
driver=com.mysql.jdbc.Driver
username=********
password=*******
#定义初始连接数  
initialSize=0 
#定义最大连接数  
maxActive=20  
#定义最大空闲  
maxIdle=20 
#定义最小空闲  
minIdle=1  
#定义最长等待时间  
maxWait=60000

  • 配置spring 引入mybatis 的配置文件（spring-mybatis.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:p="http://www.springframework.org/schema/p"  
    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-3.1.xsd    
  http://www.springframework.org/schema/context    
  http://www.springframework.org/schema/context/spring-context-3.1.xsd    
  http://www.springframework.org/schema/mvc    
  http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">  
  
    <!-- 自动扫描 -->  
    <context:component-scan base-package="com.test" />  
  
    <!-- 引入配置文件 -->  
    <bean id="propertyConfigurer"  
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="location" value="classpath:jdbc.properties" />  
    </bean>  
  
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"  
        destroy-method="close">  
        <property name="driverClassName" value="${driver}" />  
        <property name="url" value="${url}" />  
        <property name="username" value="${username}" />  
        <property name="password" value="${password}" />  
        <!-- 初始化连接大小 -->  
        <property name="initialSize" value="${initialSize}"></property>  
        <!-- 连接池最大数量 -->  
        <property name="maxActive" value="${maxActive}"></property>  
        <!-- 连接池最大空闲 -->  
        <property name="maxIdle" value="${maxIdle}"></property>  
        <!-- 连接池最小空闲 -->  
        <property name="minIdle" value="${minIdle}"></property>  
        <!-- 获取连接最大等待时间 -->  
        <property name="maxWait" value="${maxWait}"></property>  
    </bean>  
  
    <!-- Spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->  
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="dataSource" ref="dataSource" />  
        <!-- 自动扫描mapping.xml文件 -->  
        <property name="mapperLocations" value="classpath:com/test/mapping/*.xml"></property>  
    </bean>  
  
    <!-- DAO接口所在包名，Spring会自动查找其下的类 -->  
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
        <property name="basePackage" value="com.test.Dao" />  
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>  
    </bean>  
  
    <!-- 事务管理 -->  
    <bean id="transactionManager"  
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource" />  
    </bean>  
  
</beans>
  • 将该配置文件添加到web.xml中 
    	<!-- The definition of the Root Spring Container shared by all Servlets and Filters -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
		/WEB-INF/spring/root-context.xml;
		classpath:spring-mybatis.xml;
		</param-value>
    到这里，我们需要的包都已经添加好了，然后我们就需要测试下我们的spring 通过mybatis与mysql 数据库是不是通的，当然我们得先把数据库，表都准备好了，这个就不说了！接下来你们可能觉得需要写代码，写一些model层出来通过mybatis与mysql进行联通了？不需要，我们只要借助一个mybatis中的神器 mybatis-generator 用来自动生成代码，当然你需要把mysql 的数据连接地址，需要生成的model 的表等一些信息配置起来！具体还是看前面链接里面的教程吧，就不重复说了：自动生成以下类：
    package com.test.Dao;

import com.test.model.UserInfo;

public interface UserInfoMapper {
    int deleteByPrimaryKey(Long positionInt);

    int insert(UserInfo record);

    int insertSelective(UserInfo record);

    UserInfo selectByPrimaryKey(Long positionInt);

    int updateByPrimaryKeySelective(UserInfo record);

    int updateByPrimaryKey(UserInfo record);
}
                      然后把接口及服务层实现写出来，就写个简单的获取用户信息吧：

                      image

                      package com.test.service;

import com.test.model.UserInfo;

public interface IUserInfoService {
	public UserInfo getUserInfoById(long pos_int);
}

                      package com.test.service.impl;

import javax.annotation.Resource;  
import org.springframework.stereotype.Service;  
import com.test.model.UserInfo;  
import com.test.Dao.UserInfoMapper;  
import com.test.service.IUserInfoService; 

@Service("userinfoService") 
public class UserInfoServiceImpl implements IUserInfoService {
	@Resource  
    private UserInfoMapper userinfoDao;  
	
	@Override  
    public UserInfo getUserInfoById(long pos_int) {  
        return this.userinfoDao.selectByPrimaryKey(pos_int);  
    }  
}

                      然后写个 jtest:

                      package smvc;

import javax.annotation.Resource;  
import org.apache.log4j.Logger;  
import org.junit.Test;  
import org.junit.runner.RunWith;  
import org.springframework.test.context.ContextConfiguration;  
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
import com.alibaba.fastjson.JSON;  
import com.test.model.UserInfo;  
import com.test.service.IUserInfoService;  


@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations = { "classpath:spring-mybatis.xml" })  
public class TestMyBatis {
	private static Logger logger = Logger.getLogger(TestMyBatis.class);  
	
	 @Resource  
	 private IUserInfoService userinfoService = null;  
	 
	 @Test  
	    public void test1() {  
	        UserInfo userinfo = userinfoService.getUserInfoById((long) 1);  
	        logger.info(JSON.toJSONString(userinfo));  
	    }  
}

                      运行下，我们就可以愉快的得到数据了！

                      web框架基础实现介绍二—Spring

                      现今，JAVA系的WEB框架基本都已Spring为基础，即使不是直接拿Spring来用，那么也只是换种方式而已。

                      组成

                      前面一篇已经基本可以知道Spring的功效：简单说，微内核的IOC框架。

                                                   image

                      上层的特性的功能虽然是外围的功能，其实是我们最关心最常用到的功能,经常我们只是按一些教程配置一下然后就能让这些功能开始工作了。但如果只是使用的话我们会对他们如何实现如何一起工作不是很了解，虽然能使用，但是不理解的话就不能举一反三。

                      再看看底下是核心的几个模块，core是基础支持模块。Context一般来说也是就用基本配置使用，除非有比较深入的使用。Beans是这个框架思想核心中的核心部分，基本上我们都是冲这个来的，因为它是实现IOC的基础，Spring 正是通过把对象包装在 Bean 中而达到对这些对象管理以及一些列额外操作的目的。接下来我们仔细看看这三个核心的模块是如何支撑起SPRING的。

                                                       image。

                      关系

                      bean由beanfactory创建，同时context 继承了beanfactory,同时也继承了core中可以读取配置文件的Resource资源接口，所以根据配置文件，context就可以创建加载各种功能beans了。

                      直接上图：image，image，

                                                               image

                      https://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/