1. Crie um projeto
Crie um projeto Maven, marque Criar um projeto simples, a id do grupo é cn.tedu.spring, a id do artefato é SpringMVC-02, a seleção de pacotes war.
Quando o projeto for criado, primeiro gere o arquivo web.xml; clique com o botão direito do mouse no projeto para definir as propriedades, verifique o Tomcat em tempos de execução direcionados; adicione a dependência spring-webmvc em pom.xml (recomendado usar a versão 4.2 ou superior https: // blog.csdn.net/qq_37669050/article/details/102384613); Copie o arquivo de configuração do Spring do projeto anterior para o novo projeto atual (https://blog.csdn.net/qq_37669050/article/details/102594279).
2. Configure o DispatcherServlet
Em primeiro lugar, você precisa configurar o DispatcherServlet em web.xml. A configuração básica é a seguinte:
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param><!-- param:参数 -->
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-ajax.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<!-- 解决SpringMVC中文乱码问题的过滤器 -->
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
O framework SpringMVC é baseado no Spring e será configurado no arquivo de configuração do Spring (spring-mvc.xml) no futuro. Espera-se que o arquivo de configuração do Spring seja carregado quando o projeto iniciar. Sim: Na configuração acima, configure o parâmetro de inicialização contextConfigLocation para DispatcherServlet. O valor deste parâmetro é a localização do arquivo de configuração Spring. Uma vez que este parâmetro seja configurado, quando o DispatcherServlet for inicializado, o arquivo de configuração Spring será carregado automaticamente! Em seguida, configure o DispatcherServlet para iniciar por padrão, ou seja, quando o Tomcat iniciar, ele inicializará o DispatcherServlet, o que fará com que o spring-mvc.xml seja lido e carregado.
A configuração suplementar é:
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
Nota: A ordem da configuração e dos nós acima é diferenciada!
Se você precisar testar se a configuração acima foi bem-sucedida, você pode primeiro configurar a verificação de componente em spring-mvc.xml:
<!-- 组件扫描 -->
<context:component-scan base-package="cn.tedu.spring"/>
Em seguida, crie qualquer classe no pacote escaneado, adicione anotações de Compontent à classe, personalize o método de construção e produza uma string, por exemplo:
package cn.tedu.spring;
import org.springframework.stereotype.Component;
@Component
public class User {
public User() {
System.out.println("创建了User类的对象！");
}
}
Finalmente, inicie o projeto e você deverá ser capaz de ver a saída no método de construção no console do Eclipse!
3. Receber solicitações enviadas por usuários por meio do controlador
Por meio da anotação @RequestMapping, você pode definir o relacionamento de mapeamento entre o caminho da solicitação e o método de processamento da solicitação, portanto, na programação real, não há necessidade de usar explicitamente o HandlerMapping.
Portanto, você pode criar diretamente a classe do controlador cn.tedu.spring.HelloController e adicionar a anotação @Controller à classe, para que a estrutura do Spring crie o objeto da classe do controlador e, finalmente, ele seja reconhecido e usado pela estrutura do SpringMVC.
Em seguida, adicione um método para processar a solicitação na classe do controlador, sobre o design do método:
- Deve usar permissões públicas;
- Use temporariamente String como o tipo de valor de retorno;
- O nome do método pode ser personalizado;
- A lista de parâmetros do método está temporariamente vazia.
Você pode adicionar métodos:
public String showHello() {
return null;
}
É necessário usar @RequestMapping antes do método para configurar a relação de mapeamento, então:
@RequestMapping("hello.do")
public String showHello() {
System.out.println("HelloController.showHello()");
return null;
}
Nota: As classes de controlador acima devem ser colocadas no pacote cn.tedu.spring, porque este pacote é a varredura de componente que foi definida anteriormente! Geralmente, a classe de controle deve usar a palavra Controller como sufixo do nome. A classe do controlador só pode usar a anotação @Controller, não @Component ou outras anotações.
Após a conclusão, reinicie o projeto, abra o navegador e teste através de http: // localhost: 8080 / SpringMVC-02 / hello.do. O resultado correto deve ser: No console do Eclipse, você pode ver a saída do método acima ! Se a página não foi processada, um erro 404 pode ocorrer.
4. Exibir página
Por padrão, se o método no controlador retorna dados do tipo String, isso significa "nome da visão" e a estrutura precisa determinar qual componente da visão é responsável pela exibição da resposta final com base no nome da visão. Você precisa configurar em spring-mvc.xml:
<!-- 模版解析器：ServletContextTemplateResolver -->
<!-- 配置ServletContextTemplateResolver时，HTML文件应该以webapp文件夹为参考 -->
<!-- 配置ClassLoaderTemplateResolver时，HTML文件应该以项目的resources文件夹为参考 -->
<bean id="templateResolver"
class="org.thymeleaf.templateresolver.ServletContextTemplateResolver">
<property name="prefix"
value="/WEB-INF/templates/" />
<property name="suffix"
value=".html" />
<property name="characterEncoding"
value="utf-8" />
<property name="templateMode"
value="HTML" />
<property name="cacheable"
value="false" />
</bean>
<!-- Spring模版引擎：SpringTemplateEngine -->
<bean id="templateEngine"
class="org.thymeleaf.spring4.SpringTemplateEngine">
<property name="templateResolver"
ref="templateResolver" />
</bean>
<!-- 视图解析器：ThymeleafViewResolver -->
<bean class="org.thymeleaf.spring4.view.ThymeleafViewResolver">
<property name="templateEngine"
ref="templateEngine" />
</bean>
Em seguida, altere o valor de retorno do método que trata a solicitação no controlador para "hello".
Por fim, crie hello.html na pasta webapp / WEB-INF / templates / e projete você mesmo o conteúdo da página em HTML. Teste por meio de http: // localhost: 8080 / SpringMVC-02 / hello.do.
Para criar um projeto Maven, use cn.tedu.mybatis para ID de grupo, MyBatis para ID de artefato e war para Packaing (você também pode escolher jar).
MyBatis
Após a criação do projeto, você precisa: gerar um arquivo web.xml; adicionar dependências em pom.xml; copiar spring-mvc.xml do projeto anterior para o projeto atual; adicionar o ambiente operacional Tomcat (neste caso pode não ser necessário); abrir o anterior No web.xml do projeto, copie a configuração de DispatcherServlet e CharacterEncodingFilter para o projeto atual.
Desta vez, você precisa adicionar dependências:
<!-- MyBatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.1</version>
</dependency>
<!-- MyBatis整合Spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.1</version>
</dependency>
<!-- SpringJDBC -->
<!-- 注意：与当前项目使用的其它spring依赖保持相同的版本号 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.10.RELEASE</version>
</dependency>
<!-- mysql连接 -->
<!-- 可选版本号：8.0.12~8.0.16，5.1.4~5.1.6 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
<!-- 数据库连接池 -->
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
Em seguida, copie spring-mvc.xml para obter spring-dao.xml, exclua a configuração no arquivo spring-dao.xml!
- Conectividade de banco de dados
Crie um arquivo db.properties em src / main / resources para configurar informações relacionadas sobre a conexão do banco de dados:
url=jdbc:mysql://localhost:3306/tedu_ums?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
driver=com.mysql.cj.jdbc.Driver
username=root
password=root
initialSize=2
maxActive=10
Ao configurar o atributo do driver, você precisa prestar atenção à versão do mysql-connector-java usada. Se você estiver usando a versão 5.x, o valor do atributo deve ser com.mysql.jdbc.Driver, se você estiver usando 6.x ou superior Versão, o valor do atributo deve ser com.mysql.cj.jdbc.Driver, se você não tiver certeza de qual valor deve ser usado, você pode expandir o arquivo jar do mysql-connector-java para observar! Além disso, há um arquivo META-INF / services / java.sql.Driver no pacote jar, que registra a classe Driver que deve ser usada ao usar o pacote jar.
Se você estiver usando mysql-connector-java da versão 6.x ou superior, você deve definir explicitamente o valor do parâmetro serverTimezone ao configurar a URL para conectar ao banco de dados! Os valores disponíveis na China Continental são Ásia / Xangai e Ásia / Chongqing.
É necessário adicionar configuração em spring-dao.xml, leia as informações de configuração no db.properties acima:
<util:properties id="config" location="classpath:db.properties" />
Então, ao se conectar ao banco de dados, a fonte de dados usada será BasicDataSource, você precisa injetar as informações de conexão do banco de dados lidas acima nas propriedades de BasicDataSource:
<!-- 配置数据源，保证其能够连接数据库 -->
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="url" value="#{config.url}" />
<property name="driverClassName" value="#{config.driver}" />
<property name="username" value="#{config.username}" />
<property name="password" value="#{config.password}" />
<property name="initialSize" value="#{config.initialSize}" />
<property name="maxActive" value="#{config.maxActive}" />
</bean>
Em seguida, você pode escrever e executar testes de unidade na classe de teste para verificar se a configuração está correta:
public class Tests {
ClassPathXmlApplicationContext ac;
@Before
public void doBefore() {
ac = new ClassPathXmlApplicationContext(
"spring-dao.xml");
}
@After
public void doAfter() {
ac.close();
}
@Test
public void getConnection() throws SQLException {
BasicDataSource dataSource = ac.getBean("dataSource", BasicDataSource.class);
Connection conn = dataSource.getConnection();
System.out.println(conn);
}
}
- Interface e método abstrato
Meta provisória: Use MyBatis para inserir novos dados do usuário na tabela de dados.
Ao usar MyBatis, você precisa definir métodos abstratos correspondentes a cada função, e esses métodos abstratos devem ser definidos na interface!
Primeiro, você deve criar o arquivo de interface cn.tedu.mybatis.UserMapper e, em seguida, definir o método abstrato de "inserir dados do usuário" na interface. O princípio de design do método abstrato:
- Se você precisar realizar uma operação de adição, exclusão ou modificação do tipo, use Integer como o valor de retorno do método, que indicará o "número de linhas afetadas", que pode ser usado para determinar o sucesso da operação, ou pode ser projetado como um int, ou pode ser projetado Vazio significa não se importar com o número de linhas afetadas;
- O nome do método pode ser personalizado e não pode ser sobrecarregado;
- A lista de parâmetros é determinada de acordo com os parâmetros necessários. Você pode consultar os pontos de interrogação em SQL ao aprender JDBC antes e escrever quais parâmetros.
A instrução SQL que precisa ser executada para "inserir dados do usuário" é aproximadamente:
insert into (username, password, age, phone, email) values (?,?,?,?,?)
O método abstrato precisa escrever 5 parâmetros. Se mais campos forem adicionados à tabela de dados posteriormente, mais parâmetros precisarão ser escritos. Essa abordagem é falha. Esses parâmetros devem ser encapsulados na classe cn.tedu.mybatis.User. dentro:
public class User {
private Integer id;
private String username;
private String password;
private Integer age;
private String phone;
private String email;
}
O método abstrato pode ser projetado como:
Integer insert(User user);
Em seguida, você precisa configurar "Onde está o arquivo de interface" para garantir que a interface possa ser encontrada quando a estrutura MyBatis funcionar:
<!-- 配置MapperScannerConfigurer -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 配置接口文件在哪里 -->
<property name="basePackage"
value="cn.tedu.mybatis" />
</bean>
- Configure o mapeamento SQL
Baixe o pacote de compactação de arquivo XML para gravar arquivos de configuração em http://doc.tedu.cn/config/mybatis-mapper.zip.
Crie uma pasta chamada mappers em src / main / resources e copie SomeMapper.xml do pacote compactado para esta pasta.
Nota: O arquivo XML usado para configurar instruções SQL no MyBatis deve incluir a seguinte instrução, caso contrário, não funcionará corretamente!
<!DOCTYPE mapper PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN" "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
Ao configurar o arquivo XML, primeiro você precisa adicionar um nó raiz e configurar o atributo namespace, que indica a qual arquivo de interface corresponde:
<!-- namespace：对应哪个接口 -->
<mapper namespace="cn.tedu.mybatis.UserMapper">
</mapper>
Em seguida, de acordo com o tipo de instrução SQL que precisa ser executada, selecione o nó filho de ,,, e. O atributo id do nó é o nome do método abstrato. Em seguida, escreva a instrução SQL que precisa ser executada no conteúdo do nó. Use # {} na parte do parâmetro. Marcador de posição de formato, o nome dentro do marcador de posição é o nome do atributo no parâmetro do método Classe de usuário:
<!-- id：抽象方法的名称 -->
<insert id="insert">
INSERT INTO t_user (
username, password,
age, phone,
email
) VALUES (
#{username}, #{password},
#{age}, #{phone},
#{email}
)
</insert>
Em seguida, você precisa configurar "Onde está o arquivo XML" e "Qual fonte de dados é usada para se conectar ao banco de dados" quando o framework é executado! Portanto, você precisa adicionar configuração em spring-dao.xml:
<!-- 配置SqlSessionFactoryBean -->
<bean class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 配置XML文件在哪里 -->
<property name="mapperLocations"
value="classpath:mappers/*.xml" />
<!-- 配置使用哪个数据源连接数据库 -->
<property name="dataSource"
ref="dataSource" />
</bean>
Finalmente, escreva e execute testes de unidade:
@Test
public void insert() {
User user = new User();
user.setUsername("zhaoqi");
user.setPassword("888999");
user.setPhone("010-88888888");
Integer rows = userMapper.insert(user);
System.out.println("rows=" + rows);
}