JAVA主流架构资料入门教程-原创手记-慕课网

概述

本文详细介绍了Java主流架构资料，包括MVC、SOA和微服务架构的概念及其应用场景，并深入讲解了Spring框架的使用方法和Hibernate与MyBatis的数据持久层技术。此外，还探讨了分布式架构的基本概念及其实现方式，包括服务发现与服务注册。

引导入门

Java架构基本概念

Java架构是指构建Java应用程序时遵循的设计模式和原则。通过采用合理的架构，可以提高软件的可维护性、可扩展性和可靠性。Java架构通常分为以下几个层次：

表示层：负责处理用户界面，通常使用Java Swing、JavaFX或Web框架（如Spring MVC）。
业务逻辑层：实现应用程序的核心功能，处理业务逻辑，通常使用Spring框架。
数据访问层：处理数据的存储和检索，常见的框架包括Hibernate和MyBatis。
持久层：负责数据的持久化存储，与数据库交互，常用数据库如MySQL、Oracle等。

了解主流Java架构及其应用场景

主流的Java架构包括MVC（Model-View-Controller）、SOA（Service-Oriented Architecture）和微服务架构。

MVC架构

定义：MVC是一种常见的软件架构模式，分为模型（Model）、视图（View）和控制器（Controller）三个部分。
应用场景：适用于Web应用和桌面应用，适用于简单的至中等复杂程度的系统。

示例代码：

// Controller
@RestController
public class UserController {
 @Autowired
 private UserService userService;

 @GetMapping("/user/{id}")
 public User getUser(@PathVariable("id") int id) {
     return userService.getUserById(id);
 }
}

// Model
public class User {
 private int id;
 private String name;
 // getters and setters
}

// Service
@Service
public class UserService {
 @Autowired
 private UserRepository userRepository;

 public User getUserById(int id) {
     return userRepository.findById(id);
 }
}

SOA架构

定义：SOA是一种将应用程序设计成离散的服务的方法，这些服务通过标准接口定义并进行交互。
应用场景：适用于大型企业级应用，需要高复用性和灵活性。

示例代码：

// Service Interface
public interface UserService {
 User getUserById(int id);
}

// Service Implementation
@Service
public class UserServiceImpl implements UserService {
 @Autowired
 private UserRepository userRepository;

 @Override
 public User getUserById(int id) {
     return userRepository.findById(id);
 }
}

微服务架构

定义：微服务架构是将一个大型的应用程序分解成一组小的服务，每个服务运行在自己的进程中，并通过轻量级的通信机制（如HTTP）进行通信。
应用场景：适用于需要快速迭代、高扩展性的大型系统。

示例代码：

// 微服务接口
@RestController
public class UserServiceController {
 @Autowired
 private UserService userService;

 @GetMapping("/user/{id}")
 public ResponseEntity<User> getUser(@PathVariable("id") int id) {
     User user = userService.getUserById(id);
     return ResponseEntity.ok(user);
 }
}

Spring框架详解

Spring框架介绍

Spring框架是一个全面的Java平台框架，用于构建企业级应用。它简化了Java开发，提供了依赖注入、事务管理、安全性和Web功能等服务。

核心容器：提供依赖注入的基本功能，管理Bean的生命周期和依赖关系。
Web模块：扩展核心容器，提供Web开发所需的功能，如Spring MVC和Spring WebFlux。
数据访问和集成模块：包括Spring JDBC、ORM、OXM、JMS、事务支持，用于数据库访问和企业服务集成。
远程访问模块：提供RMI、Hessian、HTTP和JMS的远程调用支持。
测试支持：简化Spring组件的集成测试。
安全模块：提供集成Spring Security的接口和工具。
Web服务模块：提供Spring WS支持Web服务开发。

Spring框架的基本使用方法

Spring框架的核心是依赖注入（DI）和控制反转（IoC）。

配置依赖

XML配置：

<bean id="userService" class="com.example.demo.UserService">
 <property name="userRepository" ref="userRepository"/>
</bean>
<bean id="userRepository" class="com.example.demo.UserRepository"/>

注解配置：

@Service
public class UserService {
 @Autowired
 private UserRepository userRepository;
}

使用Bean

XML配置：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) context.getBean("userService");

注解配置：

@Configuration
public class AppConfig {
 @Bean
 public UserService userService() {
     UserService userService = new UserService();
     userService.setUserRepository(userRepository());
     return userService;
 }

 @Bean
 public UserRepository userRepository() {
     return new UserRepository();
 }
}

Hibernate与MyBatis数据持久层技术

数据持久层的重要性

数据持久层是应用程序中负责数据存储和检索的部分。它的主要任务是将数据保存到数据库，从数据库中读取数据，并执行必要的事务操作。一个好的数据持久层可以提高系统的性能、可靠性和可维护性。

数据映射：数据持久层将对象模型映射到关系型数据库模型上。
事务处理：处理数据库的事务操作，确保数据的一致性和完整性。
缓存机制：提高数据访问的效率，减少数据库的访问频率。

Hibernate与MyBatis的使用入门

Hibernate

配置文件：

<hibernate-configuration>
 <session-factory>
     <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
     <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
     <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
     <property name="hibernate.connection.username">root</property>
     <property name="hibernate.connection.password">password</property>
     <property name="hibernate.show_sql">true</property>
 </session-factory>
</hibernate-configuration>

映射文件：

<hibernate-mapping>
 <class name="com.example.demo.User" table="users">
     <id name="id" column="id" type="int">
         <generator class="native"/>
     </id>
     <property name="name" column="name" type="string"/>
     <property name="email" column="email" type="string"/>
 </class>
</hibernate-mapping>

代码示例：

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Session session = sessionFactory.openSession();

Transaction transaction = session.beginTransaction();
User user = new User("John", "john@example.com");
session.save(user);

transaction.commit();
session.close();

MyBatis

配置文件：

<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/test"/>
             <property name="username" value="root"/>
             <property name="password" value="password"/>
         </dataSource>
     </environment>
 </environments>
 <mappers>
     <mapper resource="UserMapper.xml"/>
 </mappers>
</configuration>

映射文件：

<mapper namespace="com.example.demo.UserMapper">
 <select id="getUserById" resultType="com.example.demo.User">
     SELECT * FROM users WHERE id = #{id}
 </select>
 <insert id="insertUser">
     INSERT INTO users (name, email) VALUES (#{name}, #{email})
 </insert>
</mapper>

代码示例：

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("MyBatisConfig.xml"));
SqlSession session = sqlSessionFactory.openSession();

UserMapper mapper = session.getMapper(UserMapper.class);
User user = new User();
user.setName("John");
user.setEmail("john@example.com");
mapper.insertUser(user);

session.commit();
session.close();

分布式架构基础

分布式架构的基本概念

分布式架构是指将应用程序部署在多个独立的计算机系统上，通过网络进行通信和协作。分布式架构可以提高系统的可扩展性、可靠性和性能。

服务发现：服务之间需要互相发现和通信，常用的服务发现机制包括Eureka、Consul和Zookeeper。
负载均衡：通过负载均衡器（如Nginx、HAProxy）将请求均匀地分发到各个服务实例。
容错和故障转移：确保系统在部分组件失效时仍能继续运行，常用的技术包括微服务、服务熔断和降级。
数据一致性：在分布式系统中，确保数据的一致性非常重要，通常使用分布式事务、两阶段提交等机制。

分布式架构在Java中的实现

Zookeeper

安装与配置：

wget http://mirror.virginia.edu/mirrors/ftp.apache.org/zookeeper/zookeeper-3.6.3/apache-zookeeper-3.6.3-bin.tar.gz
tar -zxvf apache-zookeeper-3.6.3-bin.tar.gz
cd apache-zookeeper-3.6.3-bin
cp conf/zoo_sample.cfg conf/zoo.cfg
bin/zkServer.sh start

代码示例：

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

public class ZookeeperClient implements Watcher {
 static final String CONNECT_STRING = "localhost:2181";
 static final int SESSION_TIMEOUT = 2000;
 static final int CONNECTION_TIMEOUT = 3000;

 ZooKeeper zk;

 @Override
 public void process(WatchedEvent event) {
     if (event.getState() == Event.KeeperState.SyncConnected) {
         System.out.println("Received event " + event.getState());
     }
 }

 public static void main(String[] args) throws Exception {
     ZookeeperClient client = new ZookeeperClient();
     client.connect();
     client.createNode();
 }

 public void connect() throws Exception {
     zk = new ZooKeeper(CONNECT_STRING, SESSION_TIMEOUT, this);
     zk.exists("/", new Watcher() {
         @Override
         public void process(WatchedEvent event) {
             System.out.println("Received event " + event.getState());
         }
     });
 }

 public void createNode() throws Exception {
     String path = "/testNode";
     zk.create(path, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
     System.out.println("Node created at path: " + path);
 }
}

Spring Cloud

服务提供者：

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

@RestController
public class HelloController {
 @GetMapping("/hello")
 public String sayHello() {
     return "Hello from Service Discovery Provider!";
 }
}

服务消费者：

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

@RestController
public class HelloController {
 @Autowired
 private RestTemplate restTemplate;

 @GetMapping("/hello")
 public String sayHello() {
     return restTemplate.getForObject("http://SERVICE-DISCOVERY-PROVIDER/hello", String.class);
 }
}

微服务架构介绍

微服务架构的定义及优势

微服务架构是一种将应用程序分解成一组小的、独立的服务的方法，每个服务运行在自己的进程中，并通过轻量级的通信机制（如HTTP）进行通信。微服务架构的主要优势包括：

可扩展性：每个服务可以独立扩展，不受其他服务的影响。
可维护性：每个服务相对独立，易于维护和测试。
容错性：服务之间松耦合，一个服务的故障不会影响整个系统。
敏捷开发：每个服务可以独立开发、部署和测试，提高了开发效率。

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

独立服务的创建

服务提供者：

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

@RestController
public class HelloController {
 @GetMapping("/hello")
 public String sayHello() {
     return "Hello from Service Discovery Provider!";
 }
}

服务消费者：

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

@RestController
public class HelloController {
 @Autowired
 private HelloService helloService;

 @GetMapping("/hello")
 public String sayHello() {
     return helloService.sayHello();
 }
}

@FeignClient(name = "SERVICE-DISCOVERY-PROVIDER")
public interface HelloService {
 @GetMapping("/hello")
 String sayHello();
}

服务注册与发现

服务提供者：

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

@RestController
public class HelloController {
 @GetMapping("/hello")
 public String sayHello() {
     return "Hello from Service Discovery Provider!";
 }
}

服务消费者：

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

@RestController
public class HelloController {
 @Autowired
 private HelloService helloService;

 @GetMapping("/hello")
 public String sayHello() {
     return helloService.sayHello();
 }
}

@FeignClient(name = "SERVICE-DISCOVERY-PROVIDER")
public interface HelloService {
 @GetMapping("/hello")
 String sayHello();
}

配置中心

配置中心：

spring:
cloud:
 config:
   server:
     git:
       uri: https://github.com/username/config-repo
       username: your-username
       password: your-password

服务端：

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

客户端：

spring:
cloud:
 config:
   uri: http://localhost:8888

实战案例

基于主流Java架构的简单项目实战

本节将通过一个简单的Spring Boot项目来演示如何使用主流的Java架构。该项目将包括用户管理、商品管理和服务发现等功能。

项目结构

User

@Entity
public class User {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 private String name;
 private String email;

 // getters and setters
}

UserService

@Service
public class UserService {
 @Autowired
private UserRepository userRepository;

 public User getUserById(Long id) {
     return userRepository.findById(id).orElse(null);
 }

 public User createUser(User user) {
     return userRepository.save(user);
 }
}

UserController

@RestController
public class UserController {
 @Autowired
 private UserService userService;

 @GetMapping("/user/{id}")
 public ResponseEntity<User> getUser(@PathVariable Long id) {
     User user = userService.getUserById(id);
     return ResponseEntity.ok(user);
 }

 @PostMapping("/user")
 public ResponseEntity<User> createUser(@RequestBody User user) {
     User createdUser = userService.createUser(user);
     return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
 }
}

商品管理

Product

@Entity
public class Product {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;
 private String name;
 private double price;

 // getters and setters
}

ProductService

@Service
public class ProductService {
 @Autowired
 private ProductRepository productRepository;

 public Product getProductById(Long id) {
     return productRepository.findById(id).orElse(null);
 }

 public Product createProduct(Product product) {
     return productRepository.save(product);
 }
}

ProductController

@RestController
public class ProductController {
 @Autowired
 private ProductService productService;

 @GetMapping("/product/{id}")
 public ResponseEntity<Product> getProduct(@PathVariable Long id) {
     Product product = productService.getProductById(id);
     return ResponseEntity.ok(product);
 }

 @PostMapping("/product")
 public ResponseEntity<Product> createProduct(@RequestBody Product product) {
     Product createdProduct = productService.createProduct(product);
     return ResponseEntity.status(HttpStatus.CREATED).body(createdProduct);
 }
}

服务发现

服务提供者：

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

@RestController
public class HelloController {
 @GetMapping("/hello")
 public String sayHello() {
     return "Hello from Service Discovery Provider!";
 }
}

服务消费者：

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

@RestController
public class HelloController {
 @Autowired
 private HelloService helloService;

 @GetMapping("/hello")
 public String sayHello() {
     return helloService.sayHello();
 }
}

@FeignClient(name = "SERVICE-DISCOVERY-PROVIDER")
public interface HelloService {
 @GetMapping("/hello")
 String sayHello();
}

构建一个简单的分布式系统

本节将通过一个简单的分布式系统案例，展示如何构建一个具有服务发现和负载均衡功能的系统。系统包括三个部分：服务提供者、服务消费者和服务注册中心。

服务提供者

配置文件：

spring:
application:
 name: service-provider

server:
port: 8081

代码示例：

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

@RestController
public class ProviderController {
 @GetMapping("/service")
 public String getService() {
     return "Service from Provider";
 }
}

服务消费者

配置文件：

spring:
application:
 name: service-consumer

server:
port: 8082

代码示例：

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

@RestController
public class ConsumerController {
 @Autowired
 private RestTemplate restTemplate;

 @GetMapping("/consumer")
 public String getConsumerService() {
     return restTemplate.getForObject("http://{service-provider}/service", String.class, "SERVICE-PROVIDER");
 }
}

服务注册中心

配置文件：

spring:
cloud:
 zookeeper:
   connect-string: localhost:2181

代码示例：

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