框架整合的配置SSS

最新推荐文章于 2021-06-15 11:07:35 发布
最新推荐文章于 2021-06-15 11:07:35 发布
阅读量5.7k 收藏 4
点赞数 1
分类专栏： 框架阶段，Spring框架 框架阶段 文章标签： 框架阶段 spring SpringMVC SpringData SSS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XXSession/article/details/78130875
版权

          这是一个基于Spring的框架   表现层利用SpringMVC    服务层利用Spring    在持久层利用SpringData  关于数据库有两种情况，这一次的框架整合时基于关系型的数据库MySQL的整合，下面就直接占代码，关于一些注意的点，以及一些别的内容会在注释中详细的给出，若有不足或者是写错的地方，请多多指教，留下你宝贵的意见

这次使用的工具是IDEA，代码使用到的是Maven这个自动化的构建工具

（一）：关于pom.xml文件，连接了本地仓库以及关联了远程仓库

<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.qf.hhh</groupId>
  <artifactId>SSSJ</artifactId>
  <packaging>war</packaging>
  <version>1.0</version>
  <name>SSSJ Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <!-- 添加junit单元测试包,版本为4.12 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- 添加servlet核心包 关联tomcat8.5 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.2-b01</version>
      <scope>provided</scope>
    </dependency>
    <!-- jstl -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- 日志记录所需包 -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>1.7.5</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.5</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.34</version>
    </dependency>
    <!-- hibernate -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <!-- for JPA, use hibernate-entitymanager instead of hibernate-core -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <!-- optional -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-osgi</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-envers</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-c3p0</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-proxool</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-infinispan</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>5.2.10.Final</version>
    </dependency>
    <!-- springdata基础包 -->
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-commons</artifactId>
      <version>1.13.0.RELEASE</version>
    </dependency>
    <!-- 链接关系型DB -->
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-jpa</artifactId>
      <version>1.11.0.RELEASE</version>
    </dependency>
    <!-- 添加Spring包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>

    <!-- 为了方便进行单元测试，添加spring-test包 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>
    <!--添加aspectjweaver包 -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.5</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>SSSJ</finalName>
  </build>
</project>

（二）：关于web.xml的配置 

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <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>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
    <!--可以起到率先加载，启动就创建对象的作用，提高程序运行的效率-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- springmvc前端控制器 -->
  <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:applicationContext.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>
</web-app>

（三）：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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/context   
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/data/jpa 
        http://www.springframework.org/schema/data/jpa/spring-jpa.xsd   
        http://www.springframework.org/schema/mvc   
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        <!--注册数据源-->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="org.gjt.mm.mysql.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///sssj?useUnicode=true&characterEncoding=utf8"></property>
		<property name="user" value="root"></property>
		<property name="password" value="root"></property>
	</bean>
	<!--创建JPA的数据管理工厂-->
        <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
	<!--注入数据源-->
	<property name="dataSource" ref="dataSource"></property>
	<!--注册实体，扫描-->
	<property name="packagesToScan" value="com.qf.pojo"></property>
	<!--配置Hibernate的属性-->
	<property name="jpaProperties">
		<props>
			<prop key="hibernate.dialect">org.hibernate.dialect.MySQL55Dialect</prop>
			<prop key="hibernate.show_sql">true</prop>
			<!--将会自动创建表-->
			<prop key="hibernate.hbm2ddl.auto">update</prop>
		</props>
	</property>
	<!--配置适配器-->
	<property name="jpaVendorAdapter">
		<!--注册Hibernate的JPA适配器对象-->
		<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
	</property>
        </bean>
	<!--创建DAo对象注入factory -->
	<!--创建SpringDataJPA 整合DAO的对象:动态创建DAO的代理实现对象 -->
	<jpa:repositories base-package="com.qf.dao" entity-manager-factory-ref="entityManagerFactory" transaction-manager-ref="jpaTransactionManager"></jpa:repositories>
	<!--创建 JPA的事务管理通知对象 -->
	<bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory"></property>
	</bean>
	<!--开启注解事务 -->
	<tx:annotation-driven transaction-manager="jpaTransactionManager"></tx:annotation-driven>
	<!--开启注解扫描和表现层共享 -->		
	<context:component-scan base-package="com.qf"></context:component-scan>
	<!--注解扫描，不需要创建服务层的对象，表现层，服务层，持久层都需要注解扫描-->
	<!--开启注解的处理器映射器和处理器适配器-->
	<mvc:annotation-driven></mvc:annotation-driven>
        <!--开启视图解析器-->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"></bean>
        <!--关于文件上传以及异常拦截的配置-->
</beans>

（四）持久层的代码 

package com.qf.dao;

import com.qf.pojo.MyCity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import javax.transaction.Transactional;
import java.util.List;

/**
 * Created by Administrator on 2017/9/28.
 */
public interface MyCityDao extends JpaRepository<MyCity,Long> {
    //这样就已经具备了CRUD和分页查询的功能
//占位符的两种方式命名占位符和索引占位符
    //添加不具备的功能，例如模糊查询,命名占位符，一一对应的形式
    @Query("from MyCity where cityName like %?1%")
    public List<MyCity> findLikeCity(String cityName);
    //方式二
    @Query("from MyCity where cityDesc=:cityDesc")
    public List<MyCity> findLikeByDescCity(@Param("cityDesc") String cityDesc);
    //这种方式其注解与其冒号后边的内容为一一对应
    //一种是利用自带的CRUD，另一种方式，可以自己写更新语句
    @Transactional
    @Modifying
    @Query("update MyCity set cityDesc =?1 where cid=?2")
    public void updateCity(String cityDesc,Long cid );
}
（五）：服务层的代码（注：关于服务层的接口，就不在这儿写了，都是先写接口，再写实现） 

package com.qf.service;

import com.qf.dao.MyCityDao;
import com.qf.dto.MyCityDto;
import com.qf.pojo.MyCity;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2017/9/28.
 */
@Service
public class MyCityServiceImpl implements MyCityService {
    //利用注解的形式去注入dao层
    @Autowired
    private MyCityDao myCityDao;

    public void setMyCityDao(MyCityDao myCityDao) {
        this.myCityDao = myCityDao;
    }

    public void addCity(MyCityDto dto) {
        MyCity pojo=new MyCity();
        BeanUtils.copyProperties(dto,pojo);
         myCityDao.save(pojo);
    }

    public void updateCity(MyCityDto dto) {
        MyCity pojo=new MyCity();
        BeanUtils.copyProperties(dto,pojo);
        myCityDao.saveAndFlush(pojo);
    }

    public void deleteCity(Long id) {
        myCityDao.delete(id);
    }

    public MyCityDto findByIdCity(Long id) {
        MyCity myCity = myCityDao.findOne(id);
        MyCityDto dto= new MyCityDto();
        BeanUtils.copyProperties(myCity,dto);
        return dto;
    }

    public List<MyCityDto> findAllCity() {
        List<MyCity> myCities = myCityDao.findAll();
        List<MyCityDto> list= new ArrayList<MyCityDto>();
        for (MyCity myCity : myCities) {
            MyCityDto dto= new MyCityDto();
            BeanUtils.copyProperties(myCity,dto);
            list.add(dto);
        }
        return list;
    }

    public List<MyCityDto> findByPage(int page, int size) {
        Pageable pageable= new PageRequest(page,size);
        List<MyCityDto> list= new ArrayList<MyCityDto>();
        Page<MyCity> cities = myCityDao.findAll(pageable);
        int totalPages = cities.getTotalPages();//获取总的页数
        List<MyCity> content = cities.getContent();//这才是获取到数据
        for (MyCity myCity : content) {
            MyCityDto dto= new MyCityDto();
            BeanUtils.copyProperties(myCity,dto);
            list.add(dto);

        }
        return list;
    }
}

（六）：表现层 

package com.qf.action;

import com.qf.dao.MyCityDao;
import com.qf.dto.MyCityDto;
import com.qf.service.MyCityService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * Created by Administrator on 2017/9/28.
 */
@Controller
public class MyCityAction {
    @Autowired
    private MyCityService myCityService;
    public void setMyCityService(MyCityService myCityService) {
        this.myCityService = myCityService;
    }
    //@Qualifier("myCityService")这个是绝对定位的意思
    @RequestMapping("/addCity.do")
    public ModelAndView addCity(HttpServletRequest request){
        ModelAndView  mv= new ModelAndView();
        String cityName = request.getParameter("cityName");
        String cityDesc = request.getParameter("cityDesc");
        MyCityDto dto= new MyCityDto();
        dto.setCityDesc(cityDesc);
        dto.setCityName(cityName);
        myCityService.addCity(dto);
        mv.setViewName("/findAllCity.do");
        return  mv;
    }
    @RequestMapping("/deleteCity.do")
    public ModelAndView deleteCity(HttpServletRequest request){
        ModelAndView  mv= new ModelAndView();
        return  mv;
    }
    @RequestMapping("/updateCity.do")
    public ModelAndView updateCity(HttpServletRequest request){
        ModelAndView  mv= new ModelAndView();
        return  mv;
    }
    @RequestMapping("/findAllCity.do")
    public ModelAndView findAllCity(HttpServletRequest request){
        ModelAndView  mv= new ModelAndView();
        List<MyCityDto> city =myCityService.findAllCity();
        mv.addObject("list",city);
        mv.setViewName("/ListCity.jsp");
        return  mv;
    }

}

（七）：测试代码 

package com.qf.test;

import com.qf.dao.MyCityDao;
import com.qf.pojo.MyCity;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;

import java.util.List;
/**
 * Created by Administrator on 2017/9/28.
 */
public class test {
    @Test
    public void addCity(){
        ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        MyCityDao dao = context.getBean(MyCityDao.class);
        MyCity city= new MyCity();
        city.setCityDesc("坐上那火车去拉萨");
        city.setCityName("西藏");
        dao.save(city);
    }
    @Test
    public void deleteCity(){
        ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        MyCityDao dao = context.getBean(MyCityDao.class);
        dao.delete(2L);
    }
    @Test
    public void updateCity(){
        ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        MyCityDao dao = context.getBean(MyCityDao.class);
        MyCity city= new MyCity();
        city.setCid(3L);
        city.setCityName("新疆");
        city.setCityDesc("地大物博");
        dao.saveAndFlush(city);
    }
    @Test
    public void findCity(){
        ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        MyCityDao dao = context.getBean(MyCityDao.class);
        MyCity daoOne = dao.findOne(3L);
        System.out.print(daoOne.getCityDesc()+"\t"+daoOne.getCityName());
    }
    @Test
    public void findAllCity(){
        ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        MyCityDao dao = context.getBean(MyCityDao.class);
        List<MyCity> daoAll =dao.findAll();
        for (MyCity myCity : daoAll) {
            System.out.println(myCity.getCityDesc()+"\t"+myCity.getCityName());
        }
    }
    //分页查询数据
    @Test
    public void findByPageCity(){
        ClassPathXmlApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        MyCityDao dao = context.getBean(MyCityDao.class);
        Pageable pageable = new PageRequest(0,2);
       //此处的分页查询与别的地方有所不同，其第一页从0开始，
        // 第二页在page 的位置输入1即可，不用自己去计算
        Page<MyCity> cities = dao.findAll(pageable);
        int totalPages = cities.getTotalPages();
        //获取总页数的方法
        for (MyCity city : cities) {
            System.out.println(city.getCityDesc()+"\t"+city.getCityName());
        }
    }
}






XXSession
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SSM框架整合--导包和环境配置
weixin_44976835的博客
01-14 386
首先需要导包 junit,数据库驱动，连接池，servlet,jsp,mybatis,mybatis <!--依赖：junit,数据库驱动，连接池，servlet,jsp,mybatis,mybatis-spring,spring,lombak,log4j--> <dependencies> <dependency> <groupId>org.projectlombok</groupId>
SSM框架整合②-log4j配置
lazyRabbit的博客
04-23 1037
记录一下log4j的配置内容 #1.配置根Logger #log4j.rootLogger = [ level ] , appenderName1, appenderName2, … #level :设定日志记录的最低级别，可设的值有OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别， # 通过在这里设定级别，您可以控制应用程序中相应级别的日志信...
SSS框架整合
Burn_的博客
08-15 2329
ssspom.xmlapplication.propertiesDao层的创建Service层的创建Service层的实现类AccountServiceImplcom.hnxy 核心类的创建web层1web层2 请求和修改 有时间转换web层 查询 pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht...
SpringData入门、SSS框架整合
08-15
SpringData一种ORM框架的在封装，你完全可以不用做任何的持久层处理，直接声明方法名就相当于声明了具体的操作，底层会根据方法名来判断你要执行什么样的操作，还可以写JPQL来做具体操作，所有的JPA操作都支持
最新SSM+SS整合框架，并附带sql文件
11-04
最新整合的spring+spring mvc+mybatis+spring security框架，附带了sql文件
sss框架搭建
Conqueror_的博客
12-13 705
ssm项目搭建
ssm框架配置文件
04-10
定义了Spring与MyBatis的整合配置，包括数据源、SqlSessionFactory、MapperScannerConfigurer等。例如，配置数据源和SqlSessionFactory： ```xml ${jdbc.driver}" /> ${jdbc.url}" /> ${jdbc.username}" /> ...
SpringBoot整合SSS框架+sessionId已一致性
weixin_41359873的博客
10-13 585
分布式主要内容 第⼀部分：⼀致性Hash算法 第⼆部分：集群时钟同步问题 第三部分：分布式ID解决⽅案 数据表A（ID），A的数据量很⼤的情况下，我们会进⾏分表操作，A（ID）表拆分成了A1表 （ID）+A2表(ID)，需要⼀种在分布式集群架构中能够产⽣全局唯⼀ID的⽅案 第四部分：分布式调度问题（定时任务的分布式） 第五部分：Session共享（⼀致性）问题 浏览器—>Nginx—>Tomcat1（Session中记录⽤户信息） —>Tomcat2 —>Tomcat3 分布式⼀定是
关于SSS框架，是对于非关系型的数据库MongoDB
XXSession的博客
09-29 1165
这个框架，在前端使用的是SpringMVC技术，服务层使用的是Spring技术，在持久层使用的是SpringData，对于数据库，我们采用的是MongoDB，这是一个非关系型的数据库，具有提高性能和处理高并发的能力，在互联网公司的使用比较广泛，有利于集群，其余的注解都会在代码中一一标出 下面是关于这个框架的配置 （一）pom.xml的配置 <project xmlns="http://mav
sss
okmy的专栏
02-19 529
ss
sss整合(spring+springMVC+spring Data Jpa)
new_ord的博客
05-22 698
导入jar包
sss即spring、springmvc、springdata、框架搭建
灵魂和肉体总要有一个在路上
10-08 866
步骤一：在pom.xml中导入如下依赖 <!-- 单元测试 --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</...
简单的SSS框架整合（简单的注册登录界面）
幸运如你的博客
10-18 6753
1、创建一个maven项目 2、pom.xml导入依赖jar包（这里需要注意的是jar包的完整性，不然会报错） Junit，spring-test：用于单元测试（不测试可以不加）；spring-data-jpa（1.11.3）；spring-webmvc（4.3.8）；hibernate-core（5.0.11）；hibernate-entitymanager（5.0.11）；javax.serv...
使用sss 框架搭建简单毕设， 宿舍管理系统
weixin_45411740的博客
06-15 300
宿舍管理系统 之前，朋友要答辩，帮他做了一个宿舍管理系统，现在他答辩完了，就把这个项目发过来 登录页面如下 项目结构如下 页面大概有30个 所有的分页，多级查询，复杂查询都可以实现 表结构如下 有需要的可以私信我，后续会上传源码，另外需要做毕设的可以联系我 ...
SSS
u014750520的博客
08-21 365
2019-8-10 [Java_SpringMVC]10.SSS 框架整合开发分析 研讨版 SpringBoot
景子墨的博客
08-13 873
文章目录10.SSS框架整合概述10.1 业务需求10.2 技术迭代10.2.1 SpringBoot10.2.2 SpringData jpa10.3 SSS框架整合实现10.3.1 项目初始化工作 :10.3.2 实体类10.3.2.1 @Entity10.3.2.2 @Table10.3.2.3 @Id10.3.2.4 @Column10.3.2 DAO Service10.3.2.1 DA...
SSS 程序结构图
幽客独往
09-03 2581
app      应用程序 | |______fiberplan |                | |                |______ConditionDialog      观测条件查看器 SssConsoleFrame  |                | |                |______Fiber      绘制光纤单元 FiberDraw  |     
2019-8-11 [Java_SpringBoot]11.SSS 框架整合开发案例 示例版
景子墨的博客
08-14 827
文章目录1.项目需求与说明2.文件目录3.maven核心配置文件 porm.xml4. entity层的Account.java5. Dao层的AccountDao.java6.Service层的AccountService.java7.Service.impl层的AccountServiceImpl8.web层8.1 DefaultAction.java8.2 AccountViewAction...
SpringDataJPA入门与SSS框架整合教程
"这篇教程介绍了SpringData的基本概念和在SSS框架中的整合，特别是SpringDataJPA的使用，包括如何简化数据访问层的开发。它还提到了SpringData支持的各种NoSQL和关系型数据库，以及在项目中集成所需的库和依赖。" ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值