项目结构图
首先配置spring支持 web.xml
配置spring配置文件 springapp-servlet.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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!-- 配置视图解析器 -->
<bean id="viewResolver"
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass"
value="org.springframework.web.servlet.view.JstlView" />
<!-- 前缀 -->
<property name="prefix" value="/" />
<!-- 后缀 -->
<property name="suffix" value=".jsp" />
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<!-- 数据库驱动 -->
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
<!-- 连接字符串 -->
<property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"></property>
<!-- 用户名 -->
<property name="username" value="system"></property>
<!-- 密码 -->
<property name="password" value="orcl"></property>
</bean>
<!-- 配置sessionFactory工厂 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="configLocation" value="classpath:myBatis_config.xml"></property>
</bean>
<!--配置模板类 这个是mybatis提供的一个辅助模板 -->
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg ref="sqlSessionFactory"></constructor-arg>
</bean>
<bean id="userDao" class="com.dragon.dao.impl.UserDaoImpl">
<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
<property name="sqlSessionTemplate" ref="sqlSessionTemplate"></property>
</bean>
<bean name="/index.action" class="com.dragon.controller.LoginController">
<property name="userDaoImpl" ref="userDao"></property>
</bean>
<bean name="/insert.action" class="com.dragon.controller.InsertController">
<property name="userDaoImpl" ref="userDao"></property>
</bean>
</beans>
配置myBatis_config.xml
<?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="lazyLoadingEnabled" value="false"/>
</settings>
<!-- 为bean 起别名 -->
<typeAliases>
<typeAlias type="com.dragon.entity.User" alias="User"/>
</typeAliases>
<!-- 配置orm映射 -->
<mappers>
<mapper resource="com/dragon/entity/user_mapper.xml"/>
</mappers>
</configuration>
实体类
package com.dragon.entity;
import java.io.Serializable;
/**
* 用户实体类
* @author Administrator
*
*/
public class User implements Serializable {
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserPassword() {
return userPassword;
}
public void setUserPassword(String userPassword) {
this.userPassword = userPassword;
}
public static long getSerialversionuid() {
return serialVersionUID;
}
/**
*
*/
private static final long serialVersionUID = 1L;
private int userId;
private String userName;
private String userPassword;
public User() {
super();
}
}
实体类的映射文件
user_mapper.xml<wbr></wbr>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"
"http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">
<mapper namespace="com.dragon.entity.User">
<!-- 配置orm映射 确保数据库中的列能和bean中的列相对应 -->
<resultMap type="User" id="user_orm">
<id property="userId" column="user_id"/>
<result property="userName" column="user_name"></result>
<result property="userPassword" column="user_password"></result>
</resultMap>
<!-- 查询全部的数据 -->
<select id="selectAll_user" parameterType="User" resultMap="user_orm" >
SELECT
user_id ,
user_name ,
user_password
FROM
UserInfo
</select>
<!-- 根据编号查询单个的数据 -->
<select id="selectById" parameterType="int" resultMap="user_orm">
SELECT * FROM
UserInfo
WHERE
user_id = #{userId}
</select>
<!-- 根据名称迷糊查询数据 -->
<select id="selectByObj" parameterType="String" resultMap="user_orm">
SELECT * FROM
UserInfo
WHERE
user_name LIKE #{userName}
</select>
<insert id="insertUser" parameterType="User" >
INSERT INTO
UserInfo
VALUES
(#{userId},#{userName},#{userPassword})
</insert>
<update id="updateUser" parameterType="User" >
UPDATE
UserInfo
SET
user_name = #{userName},
user_password = #{userPassword}
WHERE
user_id = #{userId}
</update>
<delete id="deleteUser" parameterType="User" >
DELETE FROM
UserInfo
WHERE
user_id=#{userId}
</delete>
</mapper>
userDao
package com.dragon.dao;
import java.util.List;
import com.dragon.entity.User;
public interface UserDao {
/**
* 获得全部的方法
* @return
*/
public abstract List<User> getAll();
/**
* 根据编号查询
* @param id
* @return
*/
public abstract User getById(int id);
/**
* 更新
* @param user
* @return
*/
public abstract int updateUser(User user);
/**
* 保存
* @param user
* @return
*/
public abstract int saveUser(User user);
/**
* 删除
* @param user
* @return
*/
public abstract int deleteUser(User user);
}
impl
package com.dragon.dao.impl;
import java.sql.SQLException;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import com.dragon.dao.UserDao;
import com.dragon.entity.User;
public class UserDaoImpl implements UserDao {
/**
* sessionFactory工厂的方法来获得对象实例
*/
private SqlSessionFactory sqlSessionFactory;
public SqlSessionFactory getSqlSessionFactory() {
return sqlSessionFactory;
}
public void setSqlSessionFactory(SqlSessionFactory sqlSessionFactory) {
this.sqlSessionFactory = sqlSessionFactory;
}
/**
* 通过mybatis提供的模板类来实现
*/
private SqlSessionTemplate sqlSessionTemplate;public SqlSessionTemplate getSqlSessionTemplate() {
return sqlSessionTemplate;
}
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlSessionTemplate = sqlSessionTemplate;
}
/**
* 查询全部的方法
*/
public List<User> getAll() {
// TODO Auto-generated method stub
List<User> userList = null;
SqlSession session1 = null;
try {
//获得session对象
//SqlSession session = this.getSqlSessionFactory().openSession();
//userList = session.selectList("selectAll_user");
///////////////使用sqlSessionTemplate模板类实现
session1 = this.getSqlSessionTemplate().getSqlSessionFactory().openSession();
//根据sql语句查询
userList = session1.selectList("selectAll_user");} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}finally{
try {
if(session1.getConnection().isClosed()==false){
session1.close();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}}
return userList;
}
public User getById(int id) {
// TODO Auto-generated method stub
User user = null;
try {
SqlSession session1 = this.getSqlSessionTemplate().getSqlSessionFactory().openSession();
user = session1.selectOne("selectById",1);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return user;
}
public int updateUser(User user) {
// TODO Auto-generated method stub
int result = 0;
try {
SqlSession session1 = this.getSqlSessionTemplate().getSqlSessionFactory().openSession();
result= session1.update("updateUser", user);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return result;
}
public int saveUser(User user) {
// TODO Auto-generated method stub
int result = 0;
try {
SqlSession session1 = this.getSqlSessionTemplate().getSqlSessionFactory().openSession();
result= session1.insert("insertUser", user);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return result;
}
public int deleteUser(User user) {
// TODO Auto-generated method stub
int result = 0;
try {
SqlSession session1 = this.getSqlSessionTemplate().getSqlSessionFactory().openSession();
result= session1.delete("deleteUser", user);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
return result;
}}
controller类 查询全部
package com.dragon.controller;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import com.dragon.dao.UserDao;
import com.dragon.entity.User;
public class LoginController implements Controller {
private UserDao userDaoImpl;
public UserDao getUserDaoImpl() {
return userDaoImpl;
}
public void setUserDaoImpl(UserDao userDaoImpl) {
this.userDaoImpl = userDaoImpl;
}
public ModelAndView handleRequest(HttpServletRequest request,
HttpServletResponse response) throws Exception {
// TODO Auto-generated method stub
//ApplicationContext context = new ClassPathXmlApplicationContext("springapp-servlet.xml");
List<User> userList = this.userDaoImpl.getAll();
System.out.println("一共有数据------------------------");
System.out.println(userList.size());
for (int i = 0; i < userList.size(); i++) {
System.out.println(userList.get(i).getUserName());
}
return new ModelAndView("index") ;
}
}
相关推荐
spring+spring mvc+mybaits搭建基础框架，内集成sqllite数据库，直接把demo中的war包放到服务器下即可运行，实现数据库密码连接等信息在配置文件中以密文形式存在des方式加密解密，。http://localhost:8090/
在"Spring MVC + Mybaits demo"中，开发者可能需要了解以下整合步骤： 1. 配置Spring MVC：添加Spring MVC的依赖，配置web.xml以启动DispatcherServlet，配置spring-servlet.xml定义Spring MVC的相关组件。 2. 配置...
【标题】"maven+spring mvc+mybaits+mysql"是一个常见的Java Web开发框架组合，用于构建高效、可维护的Web应用程序。这个项目利用了Maven作为构建工具，Spring MVC作为控制器层，MyBatis作为数据访问层，以及MySQL...
该项目是结合上次所分享的电商设计文档资源，所完成的基于Mysql+Spring+SpringMVC+Mybaits框架的JavaWeb项目源代码，非常有利于了解JavaWeb框架的使用和了解，还可以基于该项目，自个按照源代码的方式，写出一套比较...
标题 "Spring+SpringMVC+Mybaits+layui+bootstrap+mysql+oracle" 提供的信息表明，这是一个基于Java的Web开发框架集成方案，用于构建高效、稳定的企业级应用。下面将详细阐述这些技术栈的核心概念及其在实际开发中的...
"maven+spring MVC+Mybatis+jetty+mysql" 的组合是常见的开发栈，它涵盖了项目管理、前端控制器、持久层操作、应用服务器以及数据库管理等多个层面。下面将详细介绍这些关键技术及其在实际应用中的作用。 1. Maven...
spring+mybaits企业应用实战 是一本不错的java 开发入门教材
标题 "spring4+springMVC+mybaits3" 提示我们关注的是Spring框架的第四版（Spring 4）与Spring MVC以及MyBatis 3的整合应用。这是一个常见的Java Web开发技术栈，用于构建高效、灵活且可扩展的企业级应用程序。 ...
Struts2、Spring和MyBatis3是Java Web开发中常用的三大开源框架，它们的整合应用可以构建出高效、灵活的MVC（Model-View-Controller）架构。本实例将详细解析这三大框架如何协同工作，提升开发效率，并提供一个基于...
【标题】"springmvc+mybaits+spring"是一个典型的Java Web开发框架组合，用于构建高效、可维护的Web应用程序。这个源码示例涵盖了MyBatis、Spring MVC和Spring这三个核心组件，它们各自承担着不同的职责。 【描述】...
在IT行业中，构建高效、可扩展的Web应用是至关重要的，而"springMvc+spring+activeMq+mybaits"这个项目组合提供了一个强大的框架基础。本文将深入探讨这四个关键技术及其相互间的协同工作。 首先，Spring MVC是...
《Spring 3.0、Spring MVC 3.0与MyBatis 3.0整合详解》 在现代Java企业级应用开发中，Spring框架因其强大的功能和灵活性而被广泛使用。Spring 3.0作为其重要的一个版本，引入了诸多改进和新特性，提升了开发效率和...
在IT行业中，Spring MVC和MyBatis是两个非常重要的开源框架，它们分别负责Web应用程序的模型-视图-控制器（MVC）架构和数据库持久化层。本文将深入探讨Spring MVC与MyBatis的整合过程，以及这两个框架各自的核心概念...
标题 "java项目，（spring+mybaits+springmvc）" 暗示这是一个基于Java技术栈的Web应用项目，采用Spring、MyBatis和SpringMVC三大框架构建。这样的组合是Java Web开发中常见的“SSM”架构，用于实现模型-视图-控制器...
SpringMVC作为Spring框架的一部分，是Java企业级应用中常用的MVC（Model-View-Controller）架构模式实现。它简化了处理HTTP请求和响应的过程，使得业务逻辑与视图层分离，提高了代码的可维护性和可测试性。在财务...
下面将详细解析这个“springboot+mybaits+html+mysql简单demo”。 1. **SpringBoot核心概念** - **自动配置**：SpringBoot通过`@EnableAutoConfiguration`注解，根据项目中的依赖自动配置相应的bean。 - **嵌入式...
该框架集合了Maven、Spring、Spring MVC、MyBatis和FreeMarker，每部分都有其独特的功能和重要性。 **Maven** 是一个项目管理和综合工具，它管理项目的构建、报告和文档。它通过POM（Project Object Model）文件来...
Spring MVC 和 MyBatis 是两个在 Java Web 开发中广泛使用的框架。Spring MVC 作为 Spring 框架的一部分，主要用于构建 MVC（Model-View-Controller）模式的 Web 应用程序，而 MyBatis 是一个优秀的持久层框架，它...
SpringMVC是Spring框架的一部分，它是一个轻量级的Web MVC框架，负责处理HTTP请求和响应，提供模型-视图-控制器（MVC）的设计模式。在SpringMVC中，Controller层接收请求，调用Service层处理业务逻辑，再通过Model将...
博客中的`applicationContext.xml`和`spring-mvc.xml`配置文件通常会包含详细的Bean配置，如数据源、SqlSessionFactory、MapperScannerConfigurer等，以及DispatcherServlet、视图解析器的配置。阅读这些配置文件有...