English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

  1. Localização
  2. Página inicial
  3. Notas de experiência
  4. Corpo do texto

Exemplo de código de integração do framework SSM baseado em Maven

Conceitos básicos

1.1、Spring

O Spring é um framework de código aberto, Spring foi lançado em2003 Foi surgido uma framework leve de desenvolvimento Java em 2002, escrita por Rod Johnson em seu livro Expert One-On-One J2Derivado de algumas ideias e protótipos descritos no EE Development and Design. Foi criado para resolver a complexidade da desenvolvimento de aplicações empresariais. O Spring usa JavaBeans básicos para fazer o que antes só era possível com EJB. No entanto, o uso do Spring não se limita ao desenvolvimento de servidor. Em termos de simplicidade, testabilidade e acoplamento fraco, qualquer aplicação Java pode beneficiar do Spring. Em termos simples, o Spring é uma框架 leve de injeção de dependência (IoC) e orientação a aspectos (AOP).

1.2, SpringMVC

Spring MVC é um produto subsequente do SpringFrameWork, que já está integrado ao Spring Web Flow. O Spring MVC separa os papéis de controlador, objeto de modelo, dispatcher e objeto de processador, o que facilita a personalização.

1.3, MyBatis

MyBatis era um projeto de código aberto da Apache, iBatis, 2010Este projeto foi migrado da Apache Software Foundation para o Google Code e renomeado para MyBatis. MyBatis é uma framework de persistência baseada em Java. O framework de persistência fornecido pelo iBATIS inclui SQL Maps e Data Access Objects (DAO). O MyBatis elimina quase todo o código JDBC e a configuração manual de parâmetros, bem como a recuperação de conjuntos de resultados. O MyBatis usa XML simples ou anotações para configuração e mapeamento original, mapeando interfaces e POJOs (Plain Old Java Objects, objetos Java comuns) para registros no banco de dados.

Primeiro passo:Crie um projeto web usando Maven.

Segundo passo:importação de pacotes jar no arquivo pom

(1) pom.xml

Eu copiei todo o meu arquivo pom.xml, algumas coisas iniciais que você deve remover, mantendo apenas a versão gerada pelo seu próprio pom.

<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.test</groupId>
 <artifactId>ssm</artifactId>
 <packaging>war</packaging>
 <version>0.0.<1-SNAPSHOT</version>
 <name>ssm Maven Webapp</name>
 <url>http://maven.apache.org</url>
 <properties> 
  <!-- número da versão do spring --> 
  <spring.version>4.0.<2.RELEASE</spring.version> 
  <!-- número da versão mybatis --> 
  <mybatis.version>3.2.6</mybatis.version> 
  <!-- log4versão do pacote de gerenciamento de arquivos de log j --> 
  <slf4j.version>1.7.7</slf4j.version> 
  <log4j.version>1.2.17</log4j.version> 
 </properties> 
 <dependencies>
 <dependency>
  <groupId>junit/groupId>
  <artifactId>junit/artifactId>
  <version>3.8.1</version>
  <escopo>test/escopo>
 </dependency>
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-core/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-web/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-oxm/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-tx/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-jdbc/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-webmvc/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-aop/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-context-support/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-test/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <!-- pacote nuclear mybatis --> 
  <dependency> 
   <groupId>org.mybatis/groupId> 
   <artifactId>mybatis/artifactId> 
   <version>${mybatis.version}/version> 
  </dependency> 
  <!-- mybatis/pacote spring --> 
  <dependency> 
   <groupId>org.mybatis/groupId> 
   <artifactId>mybatis-spring/artifactId> 
   <version>1.2.2</version> 
  </dependency> 
  <!-- importar o pacote jar java ee --> 
  <dependency> 
   <groupId>javax/groupId> 
   <artifactId>javaee-api/artifactId> 
   <version>7.0</version> 
  </dependency> 
  <!-- importar o pacote jar de conexão do banco de dados Mysql --> 
  <dependency> 
   <groupId>mysql/groupId> 
   <artifactId>mysql-connector-java</artifactId> 
   <version>5.1.30</version> 
  </dependency> 
  <!-- importar o pacote jar dbcp, usado para configurar o banco de dados no applicationContext.xml --> 
  <dependency> 
   <groupId>commons-dbcp/groupId> 
   <artifactId>commons-dbcp/artifactId> 
   <version>1.2.2</version> 
  </dependency> 
  <!-- classe de etiquetas JSTL --> 
  <dependency> 
   <groupId>jstl/groupId> 
   <artifactId>jstl/artifactId> 
   <version>1.2</version> 
  </dependency> 
  <!-- pacote de gerenciamento de arquivos de log --> 
  <!-- log inicial --> 
  <dependency> 
   <groupId>log4j</groupId> 
   <artifactId>log4j</artifactId> 
   <version>${log4j.version</version> 
  </dependency> 
  <!-- formatação de objeto, facilitando a saída de logs --> 
  <dependency> 
   <groupId>com.alibaba/groupId> 
   <artifactId>fastjson/artifactId> 
   <version>1.1.41</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> 
  <!-- log finalizado --> 
  <!-- injetar JSON --> 
  <dependency> 
   <groupId>org.codehaus.jackson/groupId> 
   <artifactId>jackson-mapper-asl</artifactId> 
   <version>1.9.13</version> 
  </dependency> 
  <!-- componente de upload --> 
  <dependency> 
   <groupId>commons-fileupload</groupId> 
   <artifactId>commons-fileupload</artifactId> 
   <version>1.3.1</version> 
  </dependency> 
  <dependency> 
   <groupId>commons-io</groupId> 
   <artifactId>commons-io</artifactId> 
   <version>2.4</version> 
  </dependency> 
  <dependency> 
   <groupId>commons-codec</groupId> 
   <artifactId>commons-codec</artifactId> 
   <version>1.9</version> 
  </dependency> 
 </dependencies>
 <build>
 <finalName>ssm</finalName>
 </build>
</project>

第三步：看整体的项目架构，先说明下我这里还没有有关springMVC的相关东西，因为我先整合sping-mybatis,在测试是否成功，成功在整合springMVC

第四步：建立model类

public class User {
 private int id;
 private String name;
 private String password;
 private String password2; 
/*提供set和get方法，toString方法*/
}

第五步：创建数据库,UserDao接口和mapper映射文件

（1）建立很简单的一张表

（2）UserDao接口

public interface UserDao {
  User findUserById(User user);
}

（3）UesrMapper.xml

<?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">
<!-- namespace命名空间，指向UserDao全路径-->
<mapper namespace="com.ssm.dao.UserDao">
 <!-- 根据id查询用户信息 -->
 <!-- 
  id：唯一标识一个statement，和UserDao方法名一致
  #{}：表示一个占位符，如果#{}中传入简单类型的参数，#{}中的名称随意
  parameterType：输入参数的类型，和UserDao()里参数一致
  resultType：输出结果类型，和UserDao()返回类型一致
  -->
 <select id="findUserById" parameterType="com.ssm.model.User" resultType="com.ssm.model.User">
  SELECT * FROM USER 
  <where>
  <if test="name != null">
   AND Name= #{name}
  </if>
  <if test="password != null">
   AND password= #{password}
  </if>
  </where> 
 </select>
 </mapper>

第五步：创建UserService和UserServiceImpl

（1）UserService

public interface UserService {
  public User getUserById(User user); 
}

（2）UserServiceImpl

import org.springframework.stereotype.Service;
import com.ssm.dao.UserDao;
import com.ssm.model.User;
import com.ssm.service.UserService;
@Service("userService")
public class UserServerImpl implements UserService {
 @Resource
 private UserDao userDao;
 public User getUserById(User user) {
  return this.userDao.findUserById(user);
 }
}

第六步：创建jdbc文件和log日志文件

（1）jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc\:mysql\://localhost\:3306/test?useUnicode=true&&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

（2）log4j.properties

log4j.rootLogger=INFO,Console,File 
#定义日志输出目的地为控制台 
log4j.appender.Console=org.apache.log4j.ConsoleAppender 
log4j.appender.Console.Target=System.out 
#可以灵活地指定日志输出格式，下面一行是指定具体的格式 
log4j.appender.Console.layout = org.apache.log4j.PatternLayout 
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n 
# Quando o tamanho do arquivo atingir o tamanho especificado, é gerado um novo arquivo 
log4j.appender.File = org.apache.log4j.RollingFileAppender 
# Especifica o diretório de saída 
log4j.appender.File.File = logs/ssm.log 
# Define o tamanho máximo do arquivo 
log4j.appender.File.MaxFileSize = 10MB 
# Exibe todos os logs, se for DEBUG, exibe logs de nível DEBUG ou superior 
log4j.appender.File.Threshold = ALL 
log4j.appender.File.layout = org.apache.log4j.PatternLayout 
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

Passo 7:Integração do 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"> 
 <!-- scaneamento automático --> 
 <context:component-scan base-package="com.ssm" /> 
 <!-- Introduzir o arquivo de configuração jdbc --> 
 <bean id="propertyConfigurer" 
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
  <property name="location" value="classpath:jdbc.properties" /> 
 </0" 
 <!-- 2.Piscina de conexões de banco de dados -->
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
  destroy-method="close"> 
  <property name="driverClassName" value="${jdbc.driver}" /> 
  <property name="url" value="${jdbc.url}" /> 
  <property name="username" value="${jdbc.username}" /> 
  <property name="password" value="${jdbc.password}" /> 
 </0" 
  <!-- Integração de Spring e MyBatis, gerenciando a fábrica de sessões SqlSessionFactory do MyBatis pelo Spring -->
 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> 
  <!-- Specify the database connection pool reference -->
  <property name="dataSource" ref="dataSource" /> 
  <!-- Automatically scan mapping.xml files --> 
  <property name="mapperLocations" value="classpath:com/ssm/mapper/*.xml"></property> 
 </0" 
 <!-- DAO interface package name, Spring will automatically find the classes under it --> 
 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> 
  <property name="basePackage" value="com.ssm.dao" /> 
  <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property> 
 </0" 
 <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx --> 
 <bean id="transactionManager" 
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
  <property name="dataSource" ref="dataSource" /> 
 </0" 
</bean>

Oitavo passo：建立测试类

经过以上步骤（log4j不配也没影响），我们已经完成了Spring和mybatis的整合，这样我们就可以编写一段测试代码来试试是否成功了。

测试类位于src/test/建立于java中，如果测试成功，表示Spring和Mybatis已经成功整合。输出信息使用的是Log4j print to console.

（1）TestMyBatis测试类

package ssm;
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.ssm.model.User;
import com.ssm.service.UserService;
/*Permite que a execução de testes ocorra no ambiente de teste do Spring*/
@RunWith(SpringJUnit4ClassRunner.class) 
/*Usado para especificar o local do arquivo de configuração do Spring a ser carregado, carregará o arquivo de configuração padrão*/
@ContextConfiguration(locations = { "classpath:spring-mybatis.xml" })
public class TestMyBatis {
 @Resource(name = "userService") 
 private UserService userService;
 @Test
 public void test1() {
  User user=new User();
  user.setName("张三");
  user.setPassword("123");
  User user1 = userService.getUserById(user);
  System.out.println(user1.toString());
 }
}

Finalmente! A chave está na saída do backend, também é o momento de testemunhar milagres, se a saída for um objeto, isso significa que você configurou a integração com sucesso!

Agora, vamos começar a integrar o SpringMVC

Passo 9:Configuração do arquivo springmvc.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"> 
 <!-- Ocorre a varredura automática do pacote, para que o SpringMVC considere que as classes anotadas com @controller no pacote são controladores --> 
 <context:component-scan base-package="com.ssm.controller" /> 
 <!--Evita que o IE execute AJAX, retornando JSON para download de arquivo --> 
 <bean id="mappingJacksonHttpMessageConverter" 
  class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"> 
  <property name="supportedMediaTypes"> 
   <list> 
    <value>text/html;charset=UTF-8</value> 
   </list> 
  </property> 
 </0" 
 <!-- Ativa a funcionalidade de anotação do SpringMVC, completando o mapeamento de solicitação e anotação POJO --> 
 <bean 
  class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 
  <property name="messageConverters"> 
   <list> 
    <ref bean="mappingJacksonHttpMessageConverter" /> <!-- Conversor JSON --> 
   </list> 
  </property> 
 </0" 
 <!-- Define o prefixo e sufixo dos arquivos de redirecionamento, configuração de modo de vista--> 
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
  <!-- Aqui, a configuração que entendo é automaticamente adicionar prefixo e sufixo ao método return da ação posterior, tornando-o um endereço URL disponível --> 
  <property name="prefix" value="/WEB-INF/jsp/" /> 
  <property name="suffix" value=".jsp" /> 
 </0" 
 <!-- Configuração de upload de arquivo de configuração, se não usar upload de arquivo, não é necessário configurar, claro, se não configurar, então não é necessário introduzir o pacote do componente de upload no arquivo de configuração --> 
 <bean id="multipartResolver" 
  class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> 
  <!-- Codificação padrão --> 
  <property name="defaultEncoding" value="utf-8" /> 
  <!-- Máximo tamanho do arquivo --> 
  <property name="maxUploadSize" value="10485760000" /> 
  <!-- Máximo valor na memória --> 
  


(2) ao escrever UserController


import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.ssm.dao.UserDao;
import com.ssm.model.User;
@Controller
public class UserController {
 @Resource
 private UserDao userDao;  
@RequestMapping("/jsp/login") 
public String login(HttpServletRequest request){
 String username=request.getParameter("username");
 String password=request.getParameter("password");
 User user=new User();
 //Consulte o banco de dados com base no nome de usuário e estudante
 user.setName(username);
 user.setPassword(password);
  User users=userDao.findUserById(user);
 //Se houver estudantes, isso significa que o login foi bem-sucedido
 if(users!=null){
  return "susscss";
 }
 //Este.jsp não foi escrito por mim, sabem, vocês podem escrever por conta própria
 return "err";
} 
}


(3)último susscss.jsp


<%@ page language="java" contentType="text/html; charset=UTF-8"
 pageEncoding="UTF-8"%>
<html>
<body>
<P>As credenciais de usuário e senha estão corretas, login bem-sucedido</P>
</body>
</html>


Perfeito!




Isso é tudo o que há no artigo. Esperamos que isso ajude no seu aprendizado e que você apóie o Tutorial Yell.
		
Declaração: O conteúdo deste artigo é extraído da Internet, pertencente ao respectivo proprietário. O conteúdo é contribuído e carregado voluntariamente pelos usuários da Internet. Este site não possui direitos de propriedade, não foi editado manualmente e não assume responsabilidade legal. Se você encontrar conteúdo suspeito de violação de direitos autorais, por favor, envie um e-mail para: notice#oldtoolbag.com (ao enviar e-mail, substitua # por @ para denunciar e forneça provas relevantes. Aos primeiros indícios de infração, o site deletará imediatamente o conteúdo suspeito de violação de direitos autorais.)
Manual básico
Você também pode gostar