基本的Java的MVC入门案例

概念：

MVC:Model View Controller:模型、视图、控制器。他是一种专门设计web程序的模式

高内聚、低耦合（高内聚：专人干专事；低耦合：让类与类之间的关系不能太紧密）

模型（Model）：是应用程序中与处理应用程序数据逻辑的部分。存数据、处理数据

视图 (View)：是应用程序中处理数据显示的部分。展示数据

控制器(Controller)：是应用程序中处理用户交互的部分。接收数据或者跳转页面

在MVC设计模式基础之上进一步的提出了java web的三层架构的思想：

表示层（web层）：包含jsp、servlet等web相关的内容

业务逻辑层（service层）：处理业务

数据库访问层（Dao层：DataBase Access Object）：也就叫做持久层，封装一些对数据库的访问细节。

项目：

如上图：

dao层是数据库访问，

service层是业务逻辑层，

web是数据展示层，用于展示。

util层一般是作为工具类的存放地点，在这里我们存放了是一个BeanFactory类（就是加载配置文件的key值，通过反射机制获取一个javabean）

加载的配置文件就是在resources下面的bean.properties

首先我们先编辑web层

package com.qf.bigdata;

import com.qf.bigdata.web.LoginServlet;

import java.util.Scanner;

public class Application {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("username:");
        String username = scanner.nextLine();
        System.out.println("password:");
        String password = scanner.nextLine();
        new LoginServlet().login(username,password);
    }
}

从Application中引入controller

package com.qf.bigdata.web;

import com.qf.bigdata.service.UserService;
import com.qf.bigdata.util.BeanFactory;

//controller
public class LoginServlet {
    private UserService userService = BeanFactory.getBean("userservice");
    public void login(String user,String pwd){
        boolean isok = userService.login(user,pwd);
        if (isok) System.out.println("登录成功");
        else System.out.println("登录失败");
    }
}

下面编写逻辑层

其实一般的逻辑层和dao层都是使用一个接口编写抽象方法，然后通过实现类去实现

package com.qf.bigdata.service;

public interface UserService {
    boolean login(String username,String password);
}

实现类

package com.qf.bigdata.service;

import com.qf.bigdata.dao.UserDao;
import com.qf.bigdata.util.BeanFactory;

public class UserServiceImpl implements UserService {
    private UserDao userDao = BeanFactory.getBean("userdao");
    @Override
    public boolean login(String username, String password) {
        return userDao.select(username,password);
    }
}

通过UserServiceImpl引入一个BeanFactory

package com.qf.bigdata.util;

import java.util.Properties;

public class BeanFactory {

    public static <T> T getBean(String key) {
        T t = null;
        Properties properties = new Properties();
        try {
            properties.load(BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties"));
            String value = properties.getProperty(key);
            Class clazz = Class.forName(value);
            t = (T) clazz.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return t;
    }
}

这里面的配置文件放在resources文件夹中

bean.properties

userservice=com.qf.bigdata.service.UserServiceImpl
userdao=com.qf.bigdata.dao.UserDaoImpl

 最后是dao层

package com.qf.bigdata.dao;

public interface UserDao {
    public boolean select(String user,String pwd);
}

package com.qf.bigdata.dao;

public class UserDaoImpl implements UserDao {
    @Override
    public boolean select(String user, String pwd) {
        if (user.equals("admin") && pwd.equals("123456")) return true;
        return false;
    }
}

笔者在程序中设置的用户名和密码是admin 和123456

Test

升级版本，使用springframework替换掉javabeanFactory

添加依赖，在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>org.example</groupId>
    <artifactId>MVC</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <java.version>1.8</java.version>
        <fastjson.version>1.2.68</fastjson.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from com.qf.bigdata.repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.ujmp</groupId>
            <artifactId>ujmp-core</artifactId>
            <version>0.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.facebook.presto</groupId>
            <artifactId>presto-jdbc</artifactId>
            <version>0.235</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-shaded-client</artifactId>
            <version>1.3.6</version>
        </dependency>

        <dependency>
            <groupId>io.milvus</groupId>
            <artifactId>milvus-sdk-java</artifactId>
            <version>0.8.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>ru.yandex.clickhouse</groupId>
            <artifactId>clickhouse-jdbc</artifactId>
            <version>0.2.4</version>
            <exclusions>
                <exclusion>
                    <artifactId>guava</artifactId>
                    <groupId>com.google.guava</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-evaluator</artifactId>
            <version>1.5.1</version>
        </dependency>

        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-evaluator-extension</artifactId>
            <version>1.5.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>com.vaadin.external.google</groupId>
                    <artifactId>android-json</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <repositories>

        <repository>
            <id>alimaven</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <updatePolicy>never</updatePolicy>
            </releases>
            <snapshots>
                <updatePolicy>never</updatePolicy>
            </snapshots>
        </repository>
    </repositories>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

在resources中新建一个新文件

新建一个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
       https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 1.annotation配置文件的方式来创建对象——ioc ： 将创建UserServiceImpl的对象交给了spring的ioc容器-->
    <!-- 开启spring的ioc的注解方式开发，但是在现在新版本的spring中，这句话可以省略 -->
    <!--<context:annotation-config />-->

    <!-- 组件扫描:配置一个包路径，在这个包路径下的被spring标识的类会被ioc容器自动创建 -->
    <context:component-scan base-package="com.qf.bigdata" />
</beans>

 组件扫描那个一定是项目的包名（以下是获取包名的步骤）

 dao层的实现类我只是标记了一下，没有其他变化

package com.qf.bigdata.dao;

import org.springframework.stereotype.Repository;

@Repository  //标记dao层
public class UserDaoImpl implements UserDao {
    @Override
    public boolean select(String user, String pwd) {
        if (user.equals("admin") && pwd.equals("123")) return true;
        return false;
    }
}

至于service层的实现类 UserDao的实例化对象删了（使用注解加载对象），添加了一个setUserDao方法

package com.qf.bigdata.service;

import com.qf.bigdata.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

/*
 * 以下四个注解都是用于对类进行标记额，只要被这四个注解其中任意一个标记都可以被spring的ioc容器创建
 * 这四个注解几乎没有区别：
 * 但是你可以明显看出来他们的单词不一样，就表示未来他们可能有区别
 */
//@Controller ： 一般在web层的ioc
//@Service ： 业务层
//@Repository ： dao层
//@Component ： 以上三者之外
@Service
public class UserServiceImpl implements UserService {

    @Autowired // 自动装配，会在ioc容器去找有没有userDao接口的子类对象，有的话就创建
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public boolean login(String username, String password) {
        return userDao.select(username, password);
    }
}

 其他方法没有变化

至于web层的TestDemo，添加了一个spring framework入口，加载配置文件

package com.qf.bigdata.web;
import com.qf.bigdata.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
    public static void main(String[] args) {
        //1. spring framework的入口类， 生成这个入口类的时候加载了我们的spring的核心配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:ApplicationContext.xml");
        //2. 得到对象
        UserService userService = (UserService) applicationContext.getBean(UserService.class);
        //3. 测试userService是否可用
        boolean isok = userService.login("admin", "123456");
        System.out.println(isok);
    }
}

运行代码

成功了