AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

java程序员怎么创建自己的网站：第四章：做个网站引入广告赚点小钱

2023-05-20 102
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，高可用系列 2核4GB
简介： java程序员怎么创建自己的网站：第四章：做个网站引入广告赚点小钱

为了节约开发时间先整一个小架构，网站初期访问不会太大，这套架构可以使用一段时间，废话不多说，开搞。


在idea中创建一个maven工程作为父工程，给它的pom.xml配置一下


<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.java.lzw</groupId>
    <artifactId>lzwmall</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <modules>
        <module>generator</module>
        <module>poral</module>
        <module>common</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--MyBatis分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.10</version>
        </dependency>
        <!--集成druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
    </dependencies>
</project>


创建一个子common工程，还是maven工程，修改pom.xml


<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.java.lzw</groupId>
    <artifactId>common</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>common</name>
    <description>common project for lzwmall</description>
    <dependencies>
        <!--Swagger-UI API文档生产工具-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>
        <!--分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.8</version>
        </dependency>
        <!--Spring Data家族有多个模块，所有的模块都基于Spring Data Commoms模块进行扩展，
        例如Spring Data JPA是针对JPA做扩展的一个子模块；Spring Data Mongo是针对MongoDB的子模块，但是共同的接口都是Spring Data。
        可以说Spring Data Commons是其所有子模块的抽象，定义了一系列的操作标准及接口。-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-commons</artifactId>
            <version>2.1.5.RELEASE</version>
        </dependency>
        <!--Hutool Java工具包-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>4.5.7</version>
        </dependency>
    </dependencies>
</project>


common的项目结构


20190516151212177.png


CommonPage

package com.common.api;
import com.github.pagehelper.PageInfo;
import org.springframework.data.domain.Page;
import java.util.List;
/**
 * 分页数据封装类
 * Created by macro on 2019/4/19.
 */
public class CommonPage<T> {
    private Integer pageNum;
    private Integer pageSize;
    private Integer totalPage;
    private Long total;
    private List<T> list;
    /**
     * 将PageHelper分页后的list转为分页信息
     */
    public static <T> CommonPage<T> restPage(List<T> list) {
        CommonPage<T> result = new CommonPage<T>();
        PageInfo<T> pageInfo = new PageInfo<T>(list);
        result.setTotalPage(pageInfo.getPages());
        result.setPageNum(pageInfo.getPageNum());
        result.setPageSize(pageInfo.getPageSize());
        result.setTotal(pageInfo.getTotal());
        result.setList(pageInfo.getList());
        return result;
    }
    /**
     * 将SpringData分页后的list转为分页信息
     */
    public static <T> CommonPage<T> restPage(Page<T> pageInfo) {
        CommonPage<T> result = new CommonPage<T>();
        result.setTotalPage(pageInfo.getTotalPages());
        result.setPageNum(pageInfo.getNumber());
        result.setPageSize(pageInfo.getSize());
        result.setTotal(pageInfo.getTotalElements());
        result.setList(pageInfo.getContent());
        return result;
    }
    public Integer getPageNum() {
        return pageNum;
    }
    public void setPageNum(Integer pageNum) {
        this.pageNum = pageNum;
    }
    public Integer getPageSize() {
        return pageSize;
    }
    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }
    public Integer getTotalPage() {
        return totalPage;
    }
    public void setTotalPage(Integer totalPage) {
        this.totalPage = totalPage;
    }
    public List<T> getList() {
        return list;
    }
    public void setList(List<T> list) {
        this.list = list;
    }
    public Long getTotal() {
        return total;
    }
    public void setTotal(Long total) {
        this.total = total;
    }
}


CommonResult


package com.common.api;
/**
 * 通用返回对象
 * Created by macro on 2019/4/19.
 */
public class CommonResult<T> {
    private long code;
    private String message;
    private T data;
    protected CommonResult() {
    }
    protected CommonResult(long code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }
    /**
     * 成功返回结果
     *
     * @param data 获取的数据
     */
    public static <T> CommonResult<T> success(T data) {
        return new CommonResult<T>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMessage(), data);
    }
    /**
     * 成功返回结果
     *
     * @param data 获取的数据
     * @param  message 提示信息
     */
    public static <T> CommonResult<T> success(T data, String message) {
        return new CommonResult<T>(ResultCode.SUCCESS.getCode(), message, data);
    }
    /**
     * 失败返回结果
     * @param errorCode 错误码
     */
    public static <T> CommonResult<T> failed(IErrorCode errorCode) {
        return new CommonResult<T>(errorCode.getCode(), errorCode.getMessage(), null);
    }
    /**
     * 失败返回结果
     * @param message 提示信息
     */
    public static <T> CommonResult<T> failed(String message) {
        return new CommonResult<T>(ResultCode.FAILED.getCode(), message, null);
    }
    /**
     * 失败返回结果
     */
    public static <T> CommonResult<T> failed() {
        return failed(ResultCode.FAILED);
    }
    /**
     * 参数验证失败返回结果
     */
    public static <T> CommonResult<T> validateFailed() {
        return failed(ResultCode.VALIDATE_FAILED);
    }
    /**
     * 参数验证失败返回结果
     * @param message 提示信息
     */
    public static <T> CommonResult<T> validateFailed(String message) {
        return new CommonResult<T>(ResultCode.VALIDATE_FAILED.getCode(), message, null);
    }
    /**
     * 未登录返回结果
     */
    public static <T> CommonResult<T> unauthorized(T data) {
        return new CommonResult<T>(ResultCode.UNAUTHORIZED.getCode(), ResultCode.UNAUTHORIZED.getMessage(), data);
    }
    /**
     * 未授权返回结果
     */
    public static <T> CommonResult<T> forbidden(T data) {
        return new CommonResult<T>(ResultCode.FORBIDDEN.getCode(), ResultCode.FORBIDDEN.getMessage(), data);
    }
    public long getCode() {
        return code;
    }
    public void setCode(long code) {
        this.code = code;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
}


IErrorCode


package com.common.api;
/**
 * 封装API的错误码
 * Created by macro on 2019/4/19.
 */
public interface IErrorCode {
    long getCode();
    String getMessage();
}


ResultCode


package com.common.api;
/**
 * 枚举了一些常用API操作码
 * Created by macro on 2019/4/19.
 */
public enum ResultCode implements IErrorCode {
    SUCCESS(200, "操作成功"),
    FAILED(500, "操作失败"),
    VALIDATE_FAILED(404, "参数检验失败"),
    UNAUTHORIZED(401, "暂未登录或token已经过期"),
    FORBIDDEN(403, "没有相关权限");
    private long code;
    private String message;
    private ResultCode(long code, String message) {
        this.code = code;
        this.message = message;
    }
    public long getCode() {
        return code;
    }
    public String getMessage() {
        return message;
    }
}


创建子工程，maven工程，作为数据层项目


<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.java.lzw</groupId>
    <artifactId>generator</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>generator</name>
    <description>generator project for lzwmall</description>
    <dependencies>
        <dependency>
            <groupId>com.java.lzw</groupId>
            <artifactId>common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- MyBatis 生成器 -->
        <dependency>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-core</artifactId>
            <version>1.3.3</version>
        </dependency>
        <!-- MyBatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <!--Mysql数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>
    </dependencies>
</project>


generator的项目架构


20190516151706684.png


CommentGenerator


package com.generator;
import org.mybatis.generator.api.IntrospectedColumn;
import org.mybatis.generator.api.IntrospectedTable;
import org.mybatis.generator.api.dom.java.CompilationUnit;
import org.mybatis.generator.api.dom.java.Field;
import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;
import org.mybatis.generator.internal.DefaultCommentGenerator;
import org.mybatis.generator.internal.util.StringUtility;
import java.util.Properties;
/**
 * 自定义注释生成器
 * Created by macro on 2018/4/26.
 */
public class CommentGenerator extends DefaultCommentGenerator {
    private boolean addRemarkComments = false;
    private static final String EXAMPLE_SUFFIX="Example";
    private static final String API_MODEL_PROPERTY_FULL_CLASS_NAME="io.swagger.annotations.ApiModelProperty";
    /**
     * 设置用户配置的参数
     */
    @Override
    public void addConfigurationProperties(Properties properties) {
        super.addConfigurationProperties(properties);
        this.addRemarkComments = StringUtility.isTrue(properties.getProperty("addRemarkComments"));
    }
    /**
     * 给字段添加注释
     */
    @Override
    public void addFieldComment(Field field, IntrospectedTable introspectedTable,
                                IntrospectedColumn introspectedColumn) {
        String remarks = introspectedColumn.getRemarks();
        //根据参数和备注信息判断是否添加备注信息
        if(addRemarkComments&&StringUtility.stringHasValue(remarks)){
//            addFieldJavaDoc(field, remarks);
            //数据库中特殊字符需要转义
            if(remarks.contains("\"")){
                remarks = remarks.replace("\"","'");
            }
            //给model的字段添加swagger注解
            field.addJavaDocLine("@ApiModelProperty(value = \""+remarks+"\")");
        }
    }
    /**
     * 给model的字段添加注释
     */
    private void addFieldJavaDoc(Field field, String remarks) {
        //文档注释开始
        field.addJavaDocLine("/**");
        //获取数据库字段的备注信息
        String[] remarkLines = remarks.split(System.getProperty("line.separator"));
        for(String remarkLine:remarkLines){
            field.addJavaDocLine(" * "+remarkLine);
        }
        addJavadocTag(field, false);
        field.addJavaDocLine(" */");
    }
    @Override
    public void addJavaFileComment(CompilationUnit compilationUnit) {
        super.addJavaFileComment(compilationUnit);
        //只在model中添加swagger注解类的导入
        if(!compilationUnit.isJavaInterface()&&!compilationUnit.getType().getFullyQualifiedName().contains(EXAMPLE_SUFFIX)){
            compilationUnit.addImportedType(new FullyQualifiedJavaType(API_MODEL_PROPERTY_FULL_CLASS_NAME));
        }
    }
}


Generator


package com.generator;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.internal.DefaultShellCallback;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
/**
 * 用于生产MBG的代码
 * Created by macro on 2018/4/26.
 */
public class Generator {
    public static void main(String[] args) throws Exception {
        //MBG 执行过程中的警告信息
        List<String> warnings = new ArrayList<String>();
        //当生成的代码重复时，覆盖原代码
        boolean overwrite = true;
        //读取我们的 MBG 配置文件
        InputStream is = Generator.class.getResourceAsStream("/generatorConfig.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(is);
        is.close();
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        //创建 MBG
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        //执行生成代码
        myBatisGenerator.generate(null);
        //输出警告信息
        for (String warning : warnings) {
            System.out.println(warning);
        }
    }
}


generator.properties


jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.connectionURL=jdbc:mysql://localhost:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
jdbc.userId=root
jdbc.password=123456


generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <properties resource="generator.properties"/>
    <context id="MySqlContext" targetRuntime="MyBatis3" defaultModelType="flat">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>
        <property name="javaFileEncoding" value="UTF-8"/>
        <!-- 为模型生成序列化方法-->
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"/>
        <!-- 为生成的Java模型创建一个toString方法 -->
        <plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>
        <commentGenerator type="com.generator.CommentGenerator">
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true"/>
            <property name="suppressDate" value="true"/>
            <property name="addRemarkComments" value="true"/>
        </commentGenerator>
        <jdbcConnection driverClass="${jdbc.driverClass}"
                        connectionURL="${jdbc.connectionURL}"
                        userId="${jdbc.userId}"
                        password="${jdbc.password}">
            <!--解决mysql驱动升级到8.0后不生成指定数据库代码的问题-->
            <property name="nullCatalogMeansCurrent" value="true" />
        </jdbcConnection>
        <javaModelGenerator targetPackage="com.generator.model" targetProject="generator\src\main\java"/>
        <sqlMapGenerator targetPackage="mapper" targetProject="generator\src\main\resources"/>
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.generator.mapper"
                             targetProject="generator\src\main\java"/>
        <!--生成全部表tableName设为%-->
        <table tableName="%">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
        </table>
    </context>
</generatorConfiguration>

如果你不想连接我的数据库，可以将generator.properties中的数据连接改为你自己的，到时运行Generator中的main方法，生成你自己的数据文件


创建一个Springboot子工程，作为门户，网站前台给用户看的，修改pom.xml


<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.java.lzw</groupId>
    <artifactId>poral</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>poral</name>
    <description>poral project for lzwmall</description>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <skipTests>true</skipTests>
    </properties>
    <parent>
        <groupId>com.java.lzw</groupId>
        <artifactId>lzwmall</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../</relativePath>
    </parent>
    <dependencies>
        <!--依赖数据层-->
        <dependency>
            <groupId>com.java.lzw</groupId>
            <artifactId>generator</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--集成logstash,logstash就是一根具备实时数据传输能力的管道，负责将数据信息从管道的输入端传输到管道的输出端；
        与此同时这根管道还可以让你根据自己的需求在中间加上滤网，Logstash提供里很多功能强大的滤网以满足你的各种应用场景。
        Logstash常用于日志关系系统中做日志采集设备-->
        <dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>4.8</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>


poral的项目架构


20190516152228576.png


config中的MyBatisConfig


package com.java.lzw.poral.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
 * MyBatis配置类
 * Created by macro on 2019/4/8.
 */
@Configuration
@EnableTransactionManagement
@MapperScan({"com.generator.mapper","com.java.lzw.poral.dao"})//第一个参数对应generator项目的mapper接口，第二个参数对应本项目自定义的dao(mapper)层接口
public class MyBatisConfig {
}


config中的SwaggerConfig


package com.java.lzw.poral.config;
import io.swagger.annotations.ApiOperation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.java.lzw.poral.controller"))
                .paths(PathSelectors.any())
                .build();
    }
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("商城前台系统")
                .description("商城前台系统")
                .contact("lzw")
                .version("1.0")
                .build();
    }
}


controller中的DemoController

package com.java.lzw.poral.controller;
import com.generator.model.OmsOrder;
import com.java.lzw.poral.service.OmsOrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
@Api(description = "测试接口")
@Controller
@RequestMapping("/demoController")
public class DemoController {
    @Autowired
    private OmsOrderService omsOrderService;
    @ApiOperation("测试")
    @RequestMapping(value = "/mail", method = RequestMethod.GET)
    @ResponseBody
    public List<OmsOrder> sendMail() {
        List<OmsOrder> orderList = omsOrderService.getOrderInfo();
        return orderList;
    }
}


dao层是你自定义的mapper接口，我这边只是做一个测试先没有写

service层的OmsOrderService

package com.java.lzw.poral.service;
import com.generator.model.OmsOrder;
import java.util.List;
public interface OmsOrderService {
    List<OmsOrder> getOrderInfo();
}


service.impl层的

package com.java.lzw.poral.service.impl;
import com.generator.mapper.OmsOrderMapper;
import com.generator.model.OmsOrder;
import com.generator.model.OmsOrderExample;
import com.java.lzw.poral.service.OmsOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class OmsOrderServiceImpl implements OmsOrderService {
    @Autowired
    private OmsOrderMapper orderMapper;
    @Override
    public List<OmsOrder> getOrderInfo() {
        OmsOrderExample omsOrderExample = new OmsOrderExample();
        OmsOrderExample.Criteria criteria = omsOrderExample.createCriteria();
        return orderMapper.selectByExample(omsOrderExample);
    }
}


启动类PoralApplication

package com.java.lzw.poral;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class PoralApplication {
    public static void main(String[] args) {
        SpringApplication.run(PoralApplication.class, args);
    }
}


resoures下的application.properties没有写

resoures下的application.yml

spring:
  profiles:
    active: dev #默认为开发环境
mybatis:
  mapper-locations:
    - classpath*:mapper/*.xml
logging:
  level:
    root: info #日志配置DEBUG,INFO,WARN,ERROR
    com.macro.mall: debug
#  file: demo_log.log #配置日志生成路径
#  path: /var/logs #配置日志文件名称


resoures下的application-dev.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mall?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    druid:
      initial-size: 5 #连接池初始化大小
      min-idle: 10 #最小空闲连接数
      max-active: 20 #最大连接数
      web-stat-filter:
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*" #不统计这些请求数据
      stat-view-servlet: #访问监控网页的登录用户名和密码
        login-username: druid
        login-password: druid


新加resoures下的logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration>
<configuration>
    <include resource="org/springframework/boot/logging/logback/defaults.xml"/>
    <include resource="org/springframework/boot/logging/logback/console-appender.xml"/>
    <!--应用名称-->
    <property name="APP_NAME" value="mall-admin"/>
    <!--日志文件保存路径-->
    <property name="LOG_FILE_PATH" value="${LOG_FILE:-${LOG_PATH:-${LOG_TEMP:-${java.io.tmpdir:-/tmp}}}/logs}"/>
    <contextName>${APP_NAME}</contextName>
    <!--每天记录日志到文件appender-->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${LOG_FILE_PATH}/${APP_NAME}-%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>${FILE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>
    <!--输出到logstash的appender-->
    <appender name="LOGSTASH" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <destination>localhost:4560</destination>
        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder"/>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
        <appender-ref ref="LOGSTASH"/>
    </root>
</configuration>


这个时候后端架构基本搭好了，小架构：springboot+mybatis+MyBatisGenerator+Swagger-UI+PageHelper


现在有二种方式，一个是在poral项目中写页面，一种是新建一个项目前后端分离


我现在一个开发就不分离了，直接写到poral项目中


poral的架构

20190516154048242.png


把你的静态资源搞进 static包里

把你的页面搞到templates里面去

修改一下application.properties文件

server.port=8084
#这里使用thymeleaf模板引擎代替jsp页面
spring.thymeleaf.mode=LEGACYHTML5
spring.thymeleaf.cache=false


使用thymeleaf需要导入依赖到poral项目中

<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf</artifactId>
    <version>2.1.4</version>
</dependency>


页面也要加头文件

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:th="http://www.thymeleaf.org">


如果不会使用thymeleaf我之前的博客中给上链接https://blog.csdn.net/java_wxid/article/details/86498332


当然如果你是新手用jsp写也没有事。


如果是前后端分离：启动后端项目在浏览器中输入：http://localhost:8084/swagger-ui.html#/


可以查看你的接口文档

20190516160610373.png

不过你需要部署你的接口到服务器，前端人员才可进行开发。


剩下的就属于你的开发时间了，网站做成什么样就看你的开发水平了，这里我就不写了。


当然我还知道有很多东西没有配置，像什么alipay，短信验证码，权限，缓存，信息队列之类的，但初期第一版也就先这样吧。


这里给上简单的项目链接可以下载：


链接：https://pan.baidu.com/s/1coEfS73tsP9wmSJ-ewb45g

提取码：fy5n


如果写好你的项目运行不报错之后就该部署项目到网上去，让用户可以通过域名访问你的网站了，部署也有二种情况，一种用自己的机器部署，一种用云服务器，而这二种可以分为普通部署和使用docker部署，这里我给上之前有部署过的项目部署流程的博客地址https://blog.csdn.net/java_wxid/article/details/89785556。


这种情况是用我的笔记本部署，用云数据库连接。当然如果你习惯了linux系统部署，而且像快速部署到云服务器上建议你购买所需的环境镜像并重装该镜像即可，这样可以少了很多配置。


重装系统操作文档链接：https://cloud.tencent.com/document/product/213/4933


需要有搭建tomcat的集成环境即可，这边为您推荐与之相关的环境供您参考。


Java运行环境（nginx+mysql+tomcat） ：https://market.cloud.tencent.com/products/6483


20190516160025217.png

现在是激动人心的时刻了，引入广告联盟，赚钱的时候了。


麒麟广告联盟（www.70e.com），支持点击和弹窗。一千点击100元。一千弹窗50元。周付，50元起付，支持网银，最好的是支持支付宝。比较好的公司运营联盟除开百度跟谷歌外，再就是酷奇广告联盟，他们那边不扣量，不扣税，不扣手续费。


这里就介绍二家，具体流程我也不好写，毕竟每家的不同，要求也不同，弄好这些杂七杂八的东西，把你的广告引入的项目中就ok了。到时直接根据访问量拿钱，所以你需要对你的网站弄一个吸引人的点，这里方式多种，我就不介绍了。


如果有疑问可以在评论下方留言，一般我都在，也可以访问我的个人网站：www.javawxid.com.cn找到我的微信私聊我


这篇我尽力了，写了这么多，点个关注呗，或者看看我的主页，相信你会关注我的。

文章标签：
云数据库 RDS MySQL 版
日志服务
Java
前端开发
容器
应用服务中间件
Linux
Maven
程序员
数据库
缓存
数据库连接
关键词：
Java程序员
Java网站
Java程序员网站
Java广告
相关实践学习
如何在云端创建MySQL数据库
开始实验后，系统会自动创建一台自建MySQL的 源数据库 ECS 实例和一台 目标数据库 RDS。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
我是廖志伟
目录
相关文章
东方睿赢
|
19天前
|
Java 程序员
JAVA程序员的进阶之路：掌握URL与URLConnection，轻松玩转网络资源！
在Java编程中，网络资源的获取与处理至关重要。本文介绍了如何使用URL与URLConnection高效、准确地获取网络资源。首先，通过`java.net.URL`类定位网络资源；其次，利用`URLConnection`类实现资源的读取与写入。文章还提供了最佳实践，包括异常处理、连接池、超时设置和请求头与响应头的合理配置，帮助Java程序员提升技能，应对复杂网络编程场景。
东方睿赢
44 9
土木林森
|
3月前
|
存储 算法 Java
惊！Java程序员必看：JVM调优揭秘，堆溢出、栈溢出如何巧妙化解？
【8月更文挑战第29天】在Java领域，JVM是代码运行的基础，但需适当调优以发挥最佳性能。本文探讨了JVM中常见的堆溢出和栈溢出问题及其解决方法。堆溢出发生在堆空间不足时，可通过增加堆空间、优化代码及释放对象解决；栈溢出则因递归调用过深或线程过多引起，调整栈大小、优化算法和使用线程池可有效应对。通过合理配置和调优JVM，可确保Java应用稳定高效运行。
土木林森
140 4
众所周知
|
3月前
|
算法 Java 程序员
在Java的编程世界里，多态不仅仅是一种代码层面的技术，它是思想的碰撞，是程序员对现实世界复杂性的抽象映射，是对软件设计哲学的深刻领悟。
在Java的编程世界里，多态不仅仅是一种代码层面的技术，它是思想的碰撞，是程序员对现实世界复杂性的抽象映射，是对软件设计哲学的深刻领悟。
众所周知
68 9
众所周知
|
3月前
|
Java 程序员
Java数据类型：为什么程序员都爱它？
Java数据类型：为什么程序员都爱它？
众所周知
52 1
游客nsyhaoxcmeiq6
|
4天前
|
SQL 存储 Java
面向 Java 程序员的 SQLite 替代品
SQLite 是轻量级数据库，适用于小微型应用，但其对外部数据源支持较弱、无存储过程等问题影响了开发效率。esProc SPL 是一个纯 Java 开发的免费开源工具，支持标准 JDBC 接口，提供丰富的数据源访问、强大的流程控制和高效的数据处理能力，尤其适合 Java 和安卓开发。SPL 代码简洁易懂，支持热切换，可大幅提高开发效率。
游客nsyhaoxcmeiq6
15 1
游客nsyhaoxcmeiq6
|
16天前
|
SQL Java 程序员
倍增 Java 程序员的开发效率
应用计算困境：Java 作为主流开发语言，在数据处理方面存在复杂度高的问题，而 SQL 虽然简洁但受限于数据库架构。SPL（Structured Process Language）是一种纯 Java 开发的数据处理语言，结合了 Java 的架构灵活性和 SQL 的简洁性。SPL 提供简洁的语法、完善的计算能力、高效的 IDE、大数据支持、与 Java 应用无缝集成以及开放性和热切换特性，能够大幅提升开发效率和性能。
游客nsyhaoxcmeiq6
46 1
mzlogin
|
22天前
|
IDE Java 程序员
C++ 程序员的 Java 指南
一个 C++ 程序员自己总结的 Java 学习中应该注意的点。
mzlogin
20 5
小白学大数据
|
1月前
|
数据采集 XML 前端开发
Jsoup在Java中：解析京东网站数据
Jsoup在Java中：解析京东网站数据
小白学大数据
71 1
WK
|
17天前
|
安全 Java 编译器
C++和Java哪个更适合开发web网站
在Web开发领域，C++和Java各具优势。C++以其高性能、低级控制和跨平台性著称，适用于需要高吞吐量和低延迟的场景，如实时交易系统和在线游戏服务器。Java则凭借其跨平台性、丰富的生态系统和强大的安全性，广泛应用于企业级Web开发，如企业管理系统和电子商务平台。选择时需根据项目需求和技术储备综合考虑。
WK
24 0
nanshaws
|
1月前
|
Java Docker 容器
java版本学习网站又添加了一个libgdx模块
java版本学习网站之前添加了docker，想了想还是再把libgdx添加进去吧。
nanshaws
29 3

热门文章

最新文章

  • 1
    Java 生成 UUID
  • 2
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 3
    【Java用法】使用Java导出word文档的解决方案（适用于从服务器上下载到本地电脑）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    JDK6笔记（5）----JDBC4
  • 6
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 7
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 8
    （十三）java类的继承
  • 9
    Java基础之004-面向对象
  • 10
    java 定时调用 bat
  • 1
    Dubbo03【管理控制台和监控中心搭建】，Java开发实用必备的几款插件
    56
  • 2
    Java中int[]与Integer[]相互转化的方法，java基础知识面试重点总结
    35
  • 3
    Java 并发编程中的锁优化策略
    34
  • 4
    Java一分钟之-设计模式：装饰器模式与代理模式
    63
  • 5
    《手把手教你》系列技巧篇（四十六）-java+ selenium自动化测试-web页面定位toast-下篇（详解教程）
    62
  • 6
    刷题两个月，从入门到字节跳动offer丨GitHub标星16k+，美团Java面试题
    65
  • 7
    《MySQL 入门教程》第 05 篇 账户和权限，Java高并发编程详解深入理解pdf
    53
  • 8
    Java的前景如何，好不好自学？，万字Java技术类校招面试题汇总
    54
  • 9
    es集群安装，邮储银行java面试
    79
  • 10
    数据结构~缓存淘汰算法--LRU算法（Java的俩种实现方式，万字解析
    97

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 基于函数计算快速搭建Zblog等传统应用框架
    • 下一篇
    阿里云OSS设置跨域访问