继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

JAVA主流架构资料入门教程

FFIVE
关注TA
已关注
手记 435
粉丝 70
获赞 459
概述

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

引导入门

Java架构基本概念

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

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

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

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

  1. 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);
       }
      }
  2. 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);
       }
      }
  3. 微服务架构

    • 定义:微服务架构是将一个大型的应用程序分解成一组小的服务,每个服务运行在自己的进程中,并通过轻量级的通信机制(如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功能等服务。

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

Spring框架的基本使用方法

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

  1. 配置依赖

    • 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;
      }
  2. 使用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数据持久层技术

数据持久层的重要性

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

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

Hibernate与MyBatis的使用入门

  1. 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();
  2. 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();

分布式架构基础

分布式架构的基本概念

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

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

分布式架构在Java中的实现

  1. 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);
       }
      }
  2. 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)进行通信。微服务架构的主要优势包括:

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

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

  1. 独立服务的创建

    • 服务提供者

      @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();
      }
  2. 服务注册与发现

    • 服务提供者

      @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();
      }
  3. 配置中心

    • 配置中心

      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架构。该项目将包括用户管理、商品管理和服务发现等功能。

  1. 项目结构

    • 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);
       }
      }
  2. 商品管理

    • 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);
       }
      }
  3. 服务发现

    • 服务提供者

      @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();
      }

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

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

  1. 服务提供者

    • 配置文件

      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";
       }
      }
  2. 服务消费者

    • 配置文件

      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");
       }
      }
  3. 服务注册中心

    • 配置文件

      spring:
      cloud:
       zookeeper:
         connect-string: localhost:2181
    • 代码示例
      @SpringBootApplication
      public class ServiceRegistryApplication {
       public static void main(String[] args) {
           SpringApplication.run(ServiceRegistryApplication.class, args);
       }
      }
打开App,阅读手记
0人推荐
发表评论
随时随地看视频慕课网APP