基于Spring+SpringMvc+Hibernate的JSP+MYSQL保健品销售网站

基于Spring+SpringMvc+Hibernate的JSP+MYSQL保健品销售网站

1.包含源程序，数据库脚本。代码和数据库脚本都有详细注释。
2.课题设计仅供参考学习使用，可以在此基础上进行扩展完善

代码已经上传github，下载地址 https://github.com/21503882/sales
开发环境：
Eclipse ,MYSQL,JDK1.8,Tomcat 7
涉及技术点：
MVC模式、SpringMvc、Mybatis、Spring、HTML、JavaScript、CSS、JQUERY、log4j、Ajax、maven等
系统采用Mybatis框架实现ORM对象关系映射，前台JSP实现，后台springMvc映射，使用Spring框架进行整合。适合学习J2EE的一段时间的熟手，代码思路清晰，注解详细，数据库用的是mysql5.1，服务器用的tomcat7，JDK版本1.8. 编程软件Eclispe J2EE版本。是典型MVC架构，并且前后台分离
主要功能：

4.3  系统功能描述
4.3.1  会员子系统功能描述
会员是系统中主要的角色，主要可以实现会员注册、购物车、顾客留言、商品浏览、订单管理、修改注册资料等功能。所以会员子系统是系统的核心模块。具体功能如下：
1．会员注册
新用户注册成会员并可以修改个人信息，注册后可以发布留言信息和购买商品等。会员在注册时，输入会员的基本信息，如会员姓名，登录账号名，用户密码，联系电话，送货地址，邮箱等信息。会员注册后可以在网站上购买商品，使用购物车等功能。
2．商品浏览
会员浏览商品信息和特价商品信息。会员进入系统后，可以按商品的分类进行浏览，也可以按关键字查询具体的商品信息进行浏览。
3．修改注册资料
登录系统的会员修改个人信息。会员可以修改自已的注册资料的信息，修改自已的联系方式等。
4．购物车
会员在浏览商品中，可以把有购买意向的商品加到购物车中，以方便在选购时进行取舍或结算，存储会员购买的商品信息待结算。
5．顾客留言
会员可以向管理员发布留言信息，会员留言后，管理员在后台可以查看到，方便顾客与系统的管理者进行交流。
6．订单管理
会员提交订单后，可以查查看自已的订单状态信息。
4.3.2  管理员子系统功能描述
管理员子系统负责整个系统各种信息的更新与维护的操作。
1．订单管理
管理员对会员的订单进行查看和删除等管理操作，管理员登录后可以查看会员的订单信息，也可以进行订单处理，会员在前台登录后可以看到自已的订单的处理情况。
2．系统用户管理
对系统的用户信息进行添加修改删除管理。完成对管理员的账号信息进行管理操作。
3．留言管理
管理员对会员发布的留言信息，以方便了解会员的诉求，处理会员的意见。
4．商品类别管理
管理员对商品的类别信息进行管理。管理员可以添加商品类别信息，也可以修改或删除商品的类别的信息。
5．特价商品
管理员发布和管理特价商品信息。管理员可以对商城中的商品进行特价设置，完成商城的商品的促销等。
6．商品管理
管理员发布和管理商品信息。管理员可以发布商品信息，可以对发布的商品信息进行管理与维护的操作。
7．会员管理
管理员对已经注册的会员进行管理。管理可以查看会员的具体信息，也可以对会员的信息进行删除的操作。

package com.aTourism.ZhouXY.controller;

import com.aTourism.ZhouXY.bean.User;
import com.aTourism.ZhouXY.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

@Controller
public class UserController {

    @Resource(name = "userService")
    private UserService userService;

    /**
     * 登录
     * @param request
     * @param user
     * @return
     */
    @RequestMapping("loging")
    public ModelAndView logining(HttpServletRequest request ,User user){
        ModelAndView mv = new ModelAndView();
        String url = "";

        Object userInfo = request.getSession().getAttribute("userInfo");
        if(userInfo != null){
            mv.addObject("backData","你已登录！！！logining success");
        }else{
            Long returnId = userService.validateLogin(user);
            if(returnId != null && returnId >0){
                mv.addObject("backData","登录成功！！！logining success");
                request.getSession().setAttribute("userInfo",returnId);
            }else{
                mv.addObject("backData","登录失败！！！your userName or password is not corret...");
            }
        }
        mv.setViewName("backData");
        return mv;
    }


}

package com.gd.orh.dto;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.gd.orh.entity.*;
import com.google.common.base.Converter;
import lombok.Data;
import org.springframework.beans.BeanUtils;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.Date;
import java.util.Optional;

@Data
public class TripOrderDTO extends BaseDTO<TripOrderDTO, TripOrder> {
    private Long tripOrderId;
    private String outTradeNo;
    private OrderStatus orderStatus;

    private Long tripId;
    private String departure;
    private Location departureLocation;
    private String destination;
    private Location destinationLocation;
    private Date createdTime;
    private Date departureTime;

    private Long passengerId;
    private Long passengerUserId;
    private String passengerUsername;
    private String passengerNickname;

    private Long driverId;
    private Long driverUserId;
    private String driverUsername;
    private String driverNickname;

    private String driverName;

    private Long carId;
    private String plateNo;
    private String brand;
    private String series;
    private String color;

    private BigDecimal lengthOfMileage;
    private Integer lengthOfTime;
    private BigDecimal MileageCost;
    private BigDecimal TimeCost;
    private BigDecimal TotalCost;

    private Long serviceRatingId;
    private Boolean isPassengerRated;
    private BigDecimal passengerRatingScore;
    private String passengerRatingContent;
    private Boolean isDriverRated;
    private BigDecimal driverRatingScore;
    private String driverRatingContent;

    private static class TripOrderDTOConverter extends Converter<TripOrderDTO, TripOrder> {

        @Override
        protected TripOrder doForward(TripOrderDTO tripOrderDTO) {
            TripOrder tripOrder = new TripOrder();
            BeanUtils.copyProperties(tripOrderDTO, tripOrder);

            tripOrder.setId(tripOrderDTO.getTripOrderId());

            Trip trip = new Trip();
            trip.setId(tripOrderDTO.getTripId());

            try {
                ObjectMapper objectMapper = new ObjectMapper();
                trip.setDepartureLocation(objectMapper.writeValueAsString(tripOrderDTO.getDepartureLocation()));
                trip.setDestinationLocation(objectMapper.writeValueAsString(tripOrderDTO.getDestinationLocation()));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }

            Passenger passenger = new Passenger();
            passenger.setId(tripOrderDTO.getPassengerId());
            trip.setPassenger(passenger);

            tripOrder.setTrip(trip);

            Driver driver = new Driver();
            driver.setId(tripOrderDTO.getDriverId());
            tripOrder.setDriver(driver);

            return tripOrder;
        }

        @Override
        protected TripOrderDTO doBackward(TripOrder tripOrder) {
            TripOrderDTO tripOrderDTO = new TripOrderDTO();
            BeanUtils.copyProperties(tripOrder, tripOrderDTO);

            tripOrderDTO.setTripOrderId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getId)
                    .orElse(null)
            );

            tripOrderDTO.setTripId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getId)
                    .orElse(null)
            );

            tripOrderDTO.setDeparture(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getDeparture)
                    .orElse(null)
            );


            tripOrderDTO.setDestination(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getDestination)
                    .orElse(null)
            );

            try {
                ObjectMapper objectMapper = new ObjectMapper();

                tripOrderDTO.setDepartureLocation(
                    objectMapper.readValue(
                        Optional.ofNullable(tripOrder)
                                .map(TripOrder::getTrip)
                                .map(Trip::getDepartureLocation)
                                .orElse(null),
                        Location.class)
                );

                tripOrderDTO.setDestinationLocation(
                    objectMapper.readValue(
                        Optional.ofNullable(tripOrder)
                                .map(TripOrder::getTrip)
                                .map(Trip::getDestinationLocation)
                                .orElse(null),
                        Location.class)
                );

            } catch (IOException e) {
                e.printStackTrace();
            }

            tripOrderDTO.setCreatedTime(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getCreatedTime)
                    .orElse(null)
            );

            tripOrderDTO.setDepartureTime(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getDepartureTime)
                    .orElse(null)
            );

            tripOrderDTO.setPassengerId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getPassenger)
                    .map(Passenger::getId)
                    .orElse(null));

            tripOrderDTO.setPassengerUserId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getPassenger)
                    .map(Passenger::getUser)
                    .map(User::getId)
                    .orElse(null));

            tripOrderDTO.setPassengerNickname(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getPassenger)
                    .map(Passenger::getUser)
                    .map(User::getNickname)
                    .orElse(null));

            tripOrderDTO.setPassengerUsername(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getTrip)
                    .map(Trip::getPassenger)
                    .map(Passenger::getUser)
                    .map(User::getUsername)
                    .orElse(null));

            tripOrderDTO.setDriverId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getId)
                    .orElse(null)
            );

            tripOrderDTO.setDriverUserId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getUser)
                    .map(User::getId)
                    .orElse(null)
            );

            tripOrderDTO.setDriverUsername(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getUser)
                    .map(User::getUsername)
                    .orElse(null)
            );

            tripOrderDTO.setDriverNickname(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getUser)
                    .map(User::getNickname)
                    .orElse(null)
            );

            tripOrderDTO.setDriverName(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getDrivingLicense)
                    .map(DrivingLicense::getDriverName)
                    .orElse(null)
            );

            tripOrderDTO.setCarId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getVehicleLicense)
                    .map(VehicleLicense::getCar)
                    .map(Car::getId)
                    .orElse(null)
            );

            tripOrderDTO.setPlateNo(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getVehicleLicense)
                    .map(VehicleLicense::getCar)
                    .map(Car::getPlateNo)
                    .orElse(null)
            );

            tripOrderDTO.setBrand(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getVehicleLicense)
                    .map(VehicleLicense::getCar)
                    .map(Car::getBrand)
                    .orElse(null)
            );

            tripOrderDTO.setSeries(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getVehicleLicense)
                    .map(VehicleLicense::getCar)
                    .map(Car::getSeries)
                    .orElse(null)
            );

            tripOrderDTO.setColor(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getDriver)
                    .map(Driver::getVehicleLicense)
                    .map(VehicleLicense::getCar)
                    .map(Car::getColor)
                    .orElse(null)
            );

            tripOrderDTO.setLengthOfMileage(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getFare)
                    .map(Fare::getLengthOfMileage)
                    .orElse(null));

            tripOrderDTO.setLengthOfTime(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getFare)
                    .map(Fare::getLengthOfTime)
                    .orElse(null));

            tripOrderDTO.setMileageCost(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getFare)
                    .map(Fare::getMileageCost)
                    .orElse(null));

            tripOrderDTO.setTimeCost(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getFare)
                    .map(Fare::getTimeCost)
                    .orElse(null));

            tripOrderDTO.setTotalCost(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getFare)
                    .map(Fare::getTotalCost)
                    .orElse(null));

            tripOrderDTO.setServiceRatingId(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getServiceRating)
                    .map(ServiceRating::getId)
                    .orElse(null));

            tripOrderDTO.setIsPassengerRated(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getServiceRating)
                    .map(ServiceRating::getIsPassengerRated)
                    .orElse(null));

            tripOrderDTO.setPassengerRatingScore(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getServiceRating)
                    .map(ServiceRating::getPassengerRatingScore)
                    .orElse(null));

            tripOrderDTO.setPassengerRatingContent(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getServiceRating)
                    .map(ServiceRating::getPassengerRatingContent)
                    .orElse(null));

            tripOrderDTO.setIsDriverRated(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getServiceRating)
                    .map(ServiceRating::getIsDriverRated)
                    .orElse(null));

            tripOrderDTO.setDriverRatingScore(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getServiceRating)
                    .map(ServiceRating::getDriverRatingScore)
                    .orElse(null));

            tripOrderDTO.setDriverRatingContent(Optional
                    .ofNullable(tripOrder)
                    .map(TripOrder::getServiceRating)
                    .map(ServiceRating::getDriverRatingContent)
                    .orElse(null));

            return tripOrderDTO;
        }
    }

    @Override
    protected Converter<TripOrderDTO, TripOrder> getConverter() {
        return new TripOrderDTOConverter();
    }
}

package com.gd.orh;

import com.corundumstudio.socketio.SocketIOServer;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.gd.orh.mapper")
public class OnlineRideHailingApplication  implements CommandLineRunner {

	@Autowired
	private SocketIOServer server;

	@Override
	public void run(String... args) {
		server.start();
	}

	public static void main(String[] args) {
		SpringApplication.run(OnlineRideHailingApplication.class, args);
	}
}