首页手记 Java主流架构学习：从入门到实践指南

Java主流架构学习：从入门到实践指南

标签：

Java 架构

本文详细介绍了Java主流架构学习的相关内容，涵盖了Java架构的基本概念、常见架构类型以及如何选择适合的架构模式。文章还深入讲解了Spring框架入门和MyBatis基础学习，并通过实战案例展示了如何使用这些技术进行开发。

Java主流架构学习：从入门到实践指南

Java架构概述

Java架构的基本概念

Java架构是设计和实现Java应用程序的一种方式，它定义了应用程序的结构、组件以及它们之间的交互方式。Java架构通常包含以下几个关键组件：

应用程序组件：这是应用程序的主要功能模块，例如Web服务、数据库访问层、业务逻辑层等。
服务层：负责处理业务逻辑和数据操作，提供服务接口供其他组件调用。
数据访问层：负责与数据库交互，执行SQL查询和数据操作。
用户界面层：负责用户交互，可以是Web界面、桌面应用或移动应用界面。
配置文件：用于管理和配置应用程序的配置数据。

常见的Java架构类型

单体架构：将应用程序的所有功能模块放在同一个进程中，所有代码在一个项目中。
分层架构：将应用程序划分为多个层次，每层有明确的功能，如表现层、业务逻辑层和数据访问层。
微服务架构：将应用程序分解成多个小型的、独立的服务，每个服务负责一个特定的业务功能。
事件驱动架构：应用程序通过事件驱动的方式响应外部或内部事件，实现异步通信。
SOA（面向服务的架构）：将应用程序设计为一组松散耦合的服务，每个服务通过标准接口进行通信。

如何选择适合的架构模式

选择适合的架构模式需要考虑以下几个因素：

业务需求：根据业务需求选择合适的架构，例如，如果业务需求变化频繁，微服务架构可能更适合。
团队规模和技术栈：团队规模和技术栈也是选择架构的重要因素，例如，大规模团队可能更倾向于微服务架构。
性能和可维护性：考虑架构的性能和可维护性，例如，分层架构在中小型项目中更容易维护。

Spring框架入门

Spring框架简介

Spring框架是一个开源的Java应用程序框架，它能够简化Java开发，并提供一系列的基础设施支持，如依赖注入、AOP（面向切面编程）、事务管理等。Spring框架的核心模块包括：

Spring Core：提供IoC（控制反转）容器，用于管理对象的生命周期和依赖关系。
Spring MVC：基于MVC模式实现Web应用的开发，提供控制器、视图和模型的支持。
Spring Data：简化数据操作，提供对各种数据访问技术的支持，如JPA、JDBC、MyBatis等。
Spring Security：提供安全支持，包括认证、授权等功能。

Spring的核心模块与特性

IoC容器

IoC（控制反转）容器是Spring的核心特性之一，它负责管理和配置应用程序中的对象。IoC容器通过配置文件或注解的方式定义对象之间的依赖关系，从而将对象的创建和管理从应用程序代码中解耦。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.printHello();
    }
}

<!-- beans.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloWorld" class="com.example.HelloWorld" />

</beans>

package com.example;

public class HelloWorld {
    public void printHello() {
        System.out.println("Hello, World!");
    }
}

AOP（面向切面编程）

AOP是一种编程范式，它将横切关注点（如日志记录、事务管理）抽取出来，以切面的形式贯穿业务逻辑。Spring AOP通过代理方式实现AOP，支持多种代理方式，包括JDK动态代理和CGLIB代理。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("Logging before method execution");
    }
}

实战：使用Spring搭建简单的Web应用

创建Spring MVC项目
配置Spring MVC
创建控制器和视图

创建Spring MVC项目

使用Maven创建一个Spring MVC项目，添加必要的依赖。

<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

配置Spring MVC

配置Spring MVC的DispatcherServlet，定义视图解析器和控制器。

<!-- web.xml -->
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

<!-- spring-servlet.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

创建控制器和视图

创建控制器类和JSP视图文件。

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {
    @GetMapping("/")
    public String index() {
        return "index";
    }
}

<!-- /WEB-INF/views/index.jsp -->
<!DOCTYPE html>
<html>
<head>
    <title>Hello</title>
</head>
<body>
    <h1>Hello, Spring MVC!</h1>
</body>
</html>

MyBatis基础学习

MyBatis的工作原理

MyBatis是一个优秀的持久层框架，它简化了数据库操作，提供了一种更简单的方式来操作关系型数据库。MyBatis的工作原理主要包括以下几个步骤：

加载配置文件：MyBatis通过读取配置文件（如XML配置文件）获取数据库连接信息和SQL映射文件。
创建会话对象：MyBatis通过配置文件创建一个SqlSessionFactory对象，该对象可以创建SqlSession对象。
执行SQL语句：SqlSession对象用于执行SQL语句，可以进行增删改查等操作。
处理结果集：MyBatis将数据库查询结果映射到Java对象，提供强类型的访问。

操作数据库的基本步骤

配置MyBatis

在项目中配置MyBatis，定义数据库连接信息和SQL映射文件。

<!-- mybatis-config.xml -->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>

<!-- com/example/UserMapper.xml -->
<mapper namespace="com.example.UserMapper">
    <select id="selectUser" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

编写Java代码

使用MyBatis提供的API执行数据库操作。

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisDemo {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
        try (SqlSession session = factory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            User user = mapper.selectUser(1);
            System.out.println(user);
        }
    }
}

package com.example;

public interface UserMapper {
    User selectUser(int id);
}

JavaBean定义

定义JavaBean类，用于映射数据库表结构。

package com.example;

public class User {
    private int id;
    private String name;
    private String email;

    // getters and setters
}

实战：使用MyBatis进行CRUD操作

实现CRUD操作

package com.example;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MyBatisCRUD {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
        try (SqlSession session = factory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);

            // Create
            User user = new User();
            user.setName("John Doe");
            user.setEmail("john.doe@example.com");
            mapper.insertUser(user);
            session.commit();

            // Read
            User readUser = mapper.selectUser(1);
            System.out.println(readUser);

            // Update
            User updateUser = mapper.selectUser(1);
            updateUser.setName("Jane Doe");
            mapper.updateUser(updateUser);
            session.commit();

            // Delete
            User deleteUser = mapper.selectUser(1);
            mapper.deleteUser(deleteUser);
            session.commit();
        }
    }
}

<!-- com/example/UserMapper.xml -->
<mapper namespace="com.example.UserMapper">
    <insert id="insertUser" parameterType="com.example.User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
    <select id="selectUser" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
    <update id="updateUser" parameterType="com.example.User">
        UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}
    </update>
    <delete id="deleteUser" parameterType="com.example.User">
        DELETE FROM users WHERE id = #{id}
    </delete>
</mapper>

package com.example;

public interface UserMapper {
    int insertUser(User user);
    User selectUser(int id);
    int updateUser(User user);
    int deleteUser(User user);
}

Java微服务入门

微服务架构的基本概念

微服务架构是一种将应用程序分解成一组小型、独立的服务的架构方式，每个服务负责一个特定的业务功能。微服务架构具有以下特点：

服务独立部署：每个服务都可以独立部署和扩展。
服务间通信：服务之间通过API或消息队列进行通信。
服务发现：服务发现机制帮助服务之间找到对方的位置。
容错机制：微服务架构中的服务具有容错机制，能够处理服务间通信的失败。

使用Spring Boot和Spring Cloud搭建微服务

创建微服务实例

创建一个简单的Spring Boot项目。
配置服务发现和注册。
实现服务间通信。

创建Spring Boot项目

使用Spring Boot Initializr创建一个新的Spring Boot项目，选择Web和Actuator依赖。

<!-- pom.xml -->
<dependencies>
    <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.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

配置服务发现和注册

在Spring Boot项目中配置Eureka服务注册与发现。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

实现服务间通信

创建一个简单的微服务应用，将服务注册到Eureka服务注册中心。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableDiscoveryClient
public class MicroserviceApplication {
    public static void main(String[] args) {
        SpringApplication.run(MicroserviceApplication.class, args);
    }

    @RestController
    public class HelloController {
        @GetMapping("/hello")
        public String hello() {
            return "Hello, Microservice!";
        }
    }
}

# application.yml
server:
  port: 8080

spring:
  cloud:
  discovery:
    enabled: true
    service-url:
      defaultZone: http://localhost:8761/eureka/

架构设计与优化技巧

设计原则与模式

设计原则

单一职责原则：每个组件应该只有一个职责，以便于维护和扩展。
模块化：将系统划分为独立的模块，每个模块负责一个特定的业务功能。
松耦合：模块之间应该尽量解耦，减少相互依赖。

设计模式

工厂模式：用于创建对象，提供一个创建对象的接口，但允许子类决定实例化哪一个类。
代理模式：为其他对象提供一个代理以控制对这个对象的访问。
策略模式：定义一系列算法，把它们一个个封装起来，并使它们可以相互替换。
观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。

性能优化方法

性能优化是确保应用程序高效运行的重要手段。常见的性能优化方法包括：

缓存：使用缓存机制减少数据库访问次数，提高响应速度。
异步处理：将耗时操作异步执行，避免阻塞主线程。
负载均衡：通过负载均衡分散请求，提高系统吞吐量。
数据库优化：优化SQL查询，使用索引等技术提高数据库性能。

实战：应用常见架构设计模式解决实际问题

工厂模式示例

// 创建接口
public interface Shape {
    void draw();
}

// 创建实现接口
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Shape: Circle");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Shape: Rectangle");
    }
}

// 创建工厂类
public class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

// 客户端代码
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Shape shape = ShapeFactory.getShape("CIRCLE");
        shape.draw();
    }
}

代理模式示例

// 创建接口
public interface Image {
    void display();
}

// 创建实现接口
public class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadFromDisk(fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }

    private void loadFromDisk(String fileName) {
        System.out.println("Loading " + fileName);
    }
}

// 创建代理类
public class ImageProxy implements Image {
    private RealImage realImage;
    private String fileName;

    public ImageProxy(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

// 客户端代码
public class ProxyPatternDemo {
    public static void main(String[] args) {
        Image image = new ImageProxy("test");
        image.display();
    }
}

策略模式示例

// 创建接口
public interface Strategy {
    int doOperation(int num1, int num2);
}

// 创建实现接口
public class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

public class OperationSubtract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

// 创建上下文类
public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context = new Context(new OperationSubtract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
    }
}

// 创建上下文类
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

观察者模式示例

// 创建接口
public interface Observer {
    void update(int temperature, int humidity, int pressure);
}

public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 创建实现接口
public class WeatherData implements Subject {
    private List<Observer> observers;
    private int temperature;
    private int humidity;
    private int pressure;

    public WeatherData() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void setWeatherData(int temperature, int humidity, int pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        notifyObservers();
    }
}

public class CurrentConditionsDisplay implements Observer {
    private WeatherData weatherData;

    public CurrentConditionsDisplay(WeatherData weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    @Override
    public void update(int temperature, int humidity, int pressure) {
        System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
    }
}

// 客户端代码
public class ObserverPatternDemo {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();
        CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);

        weatherData.setWeatherData(80, 65, 30);
    }
}

开发工具与测试

常用开发工具介绍

开发Java应用程序时，常用的一些开发工具包括：

IDEA：IntelliJ IDEA是一个功能强大的Java集成开发环境，提供了代码编辑、调试、版本控制等功能。
Eclipse：Eclipse是一个开源的Java IDE，它提供了一系列的插件和工具，支持多种编程语言。
Maven：Maven是一个项目管理和构建工具，它能够帮助管理项目依赖和构建过程。
Gradle：Gradle是一个基于Groovy语言的构建工具，它能够替代Maven和Ant，支持更灵活的构建过程。
Git：Git是一个分布式版本控制系统，它支持多人协作开发，能够跟踪代码变化。

单元测试与集成测试

测试是确保代码质量的重要手段，常见的测试类型包括：

单元测试：测试单个组件或模块的功能。
集成测试：测试多个组件或模块之间的交互。
系统测试：测试整个系统的功能和性能。
验收测试：测试系统是否满足用户的业务需求。

单元测试示例

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class MathUtilTest {
    @Test
    public void testAdd() {
        MathUtil mathUtil = new MathUtil();
        assertEquals(7, mathUtil.add(2, 5));
    }

    @Test
    public void testSubtract() {
        MathUtil mathUtil = new MathUtil();
        assertEquals(3, mathUtil.subtract(5, 2));
    }
}

public class MathUtil {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }
}

集成测试示例

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class IntegrationTest {
    @Test
    public void testIntegration() {
        DatabaseUtil dbUtil = new DatabaseUtil();
        boolean result = dbUtil.insertUser("John Doe", "john.doe@example.com");
        assertTrue(result);
    }
}

public class DatabaseUtil {
    public boolean insertUser(String name, String email) {
        // Simulate database insertion
        return true;
    }
}

实战：使用JUnit和Mockito进行测试

创建一个简单的应用程序。
使用JUnit进行单元测试。
使用Mockito进行集成测试。

创建应用程序

public class MathUtil {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }
}

使用JUnit进行单元测试

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class MathUtilTest {
    @Test
    public void testAdd() {
        MathUtil mathUtil = new MathUtil();
        assertEquals(7, mathUtil.add(2, 5));
    }

    @Test
    public void testSubtract() {
        MathUtil mathUtil = new MathUtil();
        assertEquals(3, mathUtil.subtract(5, 2));
    }
}

使用Mockito进行集成测试

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

public class IntegrationTest {
    @Test
    public void testIntegration() {
        DatabaseUtil dbUtil = mock(DatabaseUtil.class);
        when(dbUtil.insertUser("John Doe", "john.doe@example.com")).thenReturn(true);
        assertTrue(dbUtil.insertUser("John Doe", "john.doe@example.com"));
    }
}

public class DatabaseUtil {
    public boolean insertUser(String name, String email) {
        // Simulate database insertion
        return true;
    }
}

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

精慕HU

手记
篇

粉丝

24

获赞与收藏

116

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342526 3164

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空