Spring与Servlet的整合

TXQIHYJ

已于 2023-12-21 11:02:01 修改

阅读量1.1k

点赞数 21

文章标签： spring servlet 数据库

于 2023-12-21 11:00:57 首次发布

本文链接：https://blog.csdn.net/TXQIHYJ/article/details/135125438

版权

实验目的

掌握Spring的配置、Bean的配置、实例化与装配方式；理解AspectJ框架来进行AOP开发；掌握Spring JDBCTemplate的常用方法；理解Spring的事务管理。

实验内容

(1) 配置applicationContext.xml文件，利用Spring负责相关对象的创建与注入；

(2) 引入Spring、SpringJDBCTemplate 重构DAO设计模式的内容

实验步骤

目录结构：

配置applicationContext.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="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">
    <context:property-placeholder location="classpath:/db.properties"/>
    <!--1. 配置数据源-->
    <!--    <bean id="driverManagerDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">-->
    <bean id="dbcpDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${mysql.driver}"/>
        <property name="url" value="${mysql.url}"/>
        <property name="username" value="${mysql.userName}"/>
        <property name="password" value="${mysql.password}"/>
    </bean>

    <!--2.配置jdbc模板-->
    <bean id="jdbcTemplateDBCP" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dbcpDataSource"/>
    </bean>

    <bean id="userDAO" class="com.txq.bmms.dao.impl.UserDaoImpl">
        <property name="jdbcTemplate" ref="jdbcTemplateDBCP"/>
    </bean>

    <!--4.配置Service-->
    <bean id="userService" class="com.txq.bmms.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDAO"/>
    </bean>


</beans>
 
mysql.driver = com.mysql.jdbc.Driver
mysql.url = jdbc:mysql://localhost:3306/bank
mysql.userName = root
mysql.password = 123456

在Spring中配置dao对象，并注入jdbcTemplate实例
<bean id="userDAO" class="com.txq.bmms.dao.impl.UserDaoImpl">
    <property name="jdbcTemplate" ref="jdbcTemplateDBCP"/>
</bean>

引入相关依赖：

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.32</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.1</version>
        <scope>provided</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <!--jstl-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-dbcp2</artifactId>
        <version>2.1.1</version>
    </dependency>

    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.4</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.4.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>  ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.4.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.1.4.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>RELEASE</version>
        <scope>compile</scope>
    </dependency>

    <!--        在pom中额外添加对spring 事务的依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.1.4.release</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>

    <!--spring web mvc-->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.4.RELEASE</version>
    </dependency>
</dependencies>

重构UserDaoImpl：

public  class UserDaoImpl implements UserDao {

    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public  int insertUser(User user){
        String insertSql = "insert into user values(null,?,?,?)";
        int row_insert = 0;
        try{
            row_insert = jdbcTemplate.update(insertSql,user.getAccount(),user.getBalance(),user.getPassword());
        }catch (Exception e){
            System.out.println("重复插入，某一唯一属性已存在");
        }

        return row_insert;

    }


    public int deleteUser(int id){
        String sql = "delete from user where id=?";
        int rowUpdate = jdbcTemplate.update(sql,id);
        return rowUpdate;



    }

    @Override
    public int updateUser(String account, double balance,String password,int id) {

        String sql = "update user set account = ?, balance = ? ,password = ? " +
                "where id=?";
        int rowUpdate = jdbcTemplate.update(sql, account,balance,password,id);
        return rowUpdate;


    }

    @Override
    public User queryUser(int id) {
        String querySql ="select * from user where id=?";
        User user;
        try{
            user = jdbcTemplate.queryForObject(querySql, new BeanPropertyRowMapper<>(User.class),id);
        }catch (Exception e){
            return null;
        }
        return user;

}

    @Override
    public User queryUserByAccountAndPwd(String account, String pwd) {
        String sql = "select * from user where account = ? and password = ?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class),account, pwd);
        return user;

测试：

对插入进行测试：

@Test
void insertUser() {
    ApplicationContext acx =new ClassPathXmlApplicationContext("/applicationContext.xml");
    UserDao userDAO = (UserDao) acx.getBean("userDAO");
    User user = new User("测试021",21,"1");
    int res = userDAO.insertUser(user);
    System.out.println(res);

}

登陆后的主界面:

增加操作：

修改操作：

删除操作：

查询操作：

遇到的问题及解决方法

遇到的问题

解决方法：

在系统中也有个username属性，这时系统变量覆盖了Properties中的值，这时取得username的值为系统的用户名Administrator，密码为properties中的password去查询数据库，此时用户名名和密码并不匹配就会报错。在Spring完成注入时是用 "${..}" 方式获取值完成注入的。而通过这种表达式也能直接获取到JVM系统属性

解决方案：

　　方案一：将properties文件中的username换成user或其他就字符串就可以成功获取连接访问数据库。建议：username是敏感词汇，为了安全起见还是尽量不要使用username。

　　方案二：在Spring配置文件中修改成：<context:property-placeholder location="classpath:/db.properties" system-properties-mode="FALLBACK "/>

FALLBACK　　--- 默认值，不存在时覆盖

NEVER　　　 --- 不覆盖

总结

本次实验主要包括两个方面的内容，即配置Spring的ApplicationContext文件并利用Spring进行对象的创建与注入，以及利用Spring和Spring JdbcTemplate对DAO设计模式进行重构。

首先，在配置ApplicationContext.xml文件方面，这是整个Spring项目的核心配置文件。通过在该文件中定义各种Bean和配置它们的依赖关系，可以实现对象的创建和注入。通过配置数据源和Spring JdbcTemplate，可以方便地进行数据库操作。这个文件起到了项目的骨架和配置中心的作用，简化了对象创建和管理的流程。

其次，通过引入Spring和Spring JdbcTemplate对DAO设计模式进行重构，可以简化数据库访问操作的代码，提高业务层代码的可维护性和可读性。在重构的过程中，可以通过注入JdbcTemplate对象来实现数据库的操作，并通过配置ApplicationContext.xml文件进行依赖关系的管理。通过这种方式，我们避免了手动管理数据库连接、处理异常等繁琐的工作，减少了冗余代码的编写。

通过完成本次实验，我对配置Spring的ApplicationContext文件以及利用Spring和Spring JdbcTemplate对DAO设计模式进行重构有了更深入的了解。可以总结出以下几点体会：

配置Spring的ApplicationContext.xml文件是整个Spring项目的基础和核心，合理配置该文件可以实现对象的声明、依赖关系的管理以及资源的注入，提高项目的可维护性和可扩展性。
引入Spring和Spring JdbcTemplate可以简化数据库操作的代码，减少手动处理数据库连接和异常的工作量。通过将数据访问的细节交给Spring框架处理，可以使DAO层的代码更加简洁，提高开发效率。
利用Spring和Spring JdbcTemplate对DAO设计模式进行重构，可以降低耦合度，增加代码的可重用性和可测试性。通过依赖注入，实现了对象之间的解耦，使得代码更加灵活。

综上所述，通过本次实验，我深入理解了Spring的配置和依赖注入的概念，并学会了如何使用Spring和Spring JdbcTemplate进行DAO设计模式的重构，以提高代码的可维护性和可读性。这对于开发大型项目和提高团队开发效率具有重要意义。