dubboo框架

最新推荐文章于 2022-05-31 19:24:24 发布

Mr.YHL

最新推荐文章于 2022-05-31 19:24:24 发布

阅读量204

点赞数

分类专栏： ssm框架文章标签：分布式 java 大数据 linux spring

本文链接：https://blog.csdn.net/weixin_41290516/article/details/109595846

版权

ssm框架专栏收录该内容

13 篇文章 0 订阅

订阅专栏

今日内容

系统架构介绍
Dubbo框架的介绍
Dubbo入门案例
Dubbo引入项目中

第一章系统架构演变(了解)

随着互联网的发展，网站应用的规模也在不断的扩大，进而导致系统架构也在不断的进行变化。

从互联网早起到现在，系统架构大体经历了下面几个过程: 单体应用架构—>垂直应用架构—>分布式架构—>SOA架构--->微服务架构

1. 单体应用架构

单体应用结构，就是将一个系统的多个模块做成一个web项目，然后部署到一台tomcat服务器上

优点：
	- 项目架构简单，小型项目的话， 开发成本低
	- 项目部署在一个节点上， 维护方便

缺点：
	- 项目模块之间紧密耦合，单点容错率低
	- 无法针对不同模块进行针对性优化和水平扩展

2. 垂直应用架构

垂直应用架构，就是将原来的一个系统拆成成多个模块，然后每个模块部署在一台tomcat服务器上

优点：
	- 可以针对不同模块进行优化和水平扩展
	- 一个系统的问题不会影响到其他系统，提高单点容错率
    
缺点：
	- 系统之间相互独立，无法进行相互调用，会有重复的开发任务

3. 分布式架构

分布式架构就是指将服务层单独部署在tomcat上对外提供服务，在controller中可以通过远程调用访问服务层中的方法

优点：
	- 抽取公共的功能为服务层，提高代码复用性

缺点：	
	- 调用关系错综复杂，难以维护

4. SOA架构

SOA结构，在分布式架构的基础上，增加一个调度中心对系统进行实时管理。

面试直达: 聊一聊集群和分布式的区别

集群:多台服务器重复完成同一个任务,即同一个任务部署在多台服务器上
分布式:多台服务器协同完成同一个任务,即同一个任务拆分为多个子任务,多个子任务部署在多台服务器上协同完成同一个任务

第二章 Dubbo概述

1. Dubbo简介

Apache Dubbo是一款高性能的Java RPC框架，可以和Spring框架无缝集成。官网地址：[http://dubbo.apache.org]

1.1 发展历程

Dubbo是阿里巴巴内部使用的分布式业务框架，2012年由阿里巴巴开源
在很短时间内，Dubbo就被许多互联网公司所采用，并产生了许多衍生版本，如网易，京东，新浪，当当等等
由于阿里策略变化，2014年10月Dubbo停止维护。随后部分互联网公司公开了自行维护的Dubbo版本，比较著名的如当当DubboX
经过三年的沉寂，在2017年9月，阿里宣布重启Dubbo项目，并决策在未来对开源进行长期持续的投入
随后Dubbo开始了密集的更新，并将停摆三年以来大量分支上的特性及缺陷修正快速整合
2018.2月，阿里将Dubbo捐献给Apache基金会，Dubbo成为Apache孵化器项目

1.2 RPC介绍

RPC全称为remote procedure call，即远程过程调用
简单的讲，RPC可以让我们像调用本地方法一样来调用远程方法
需要注意的是RPC并不是一个具体的技术，而是指整个网络远程调用过程
Java中的RPC框架比较多，广泛使用的有RMI、Hessian、Dubbo等

1.3 核心能力

面向接口的远程方法调用
智能容错和负载均衡
服务自动注册和发现

2. Dubbo架构(重点手画)

节点角色说明：

节点	角色名称
Provider	暴露服务的服务提供方
Consumer	调用远程服务的服务消费方
Registry	服务注册与发现的注册中心
Monitor	统计服务的调用次数和调用时间的监控中心
Container	服务运行容器

调用关系说明:

服务容器负责启动，加载，运行服务提供者。
服务提供者在启动时，向注册中心注册自己提供的服务。
服务消费者在启动时，向注册中心订阅自己所需的服务。
注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

面试直达:

服务调用者和注册中心是基于推模式还是拉模式获取服务的

如果服务注册中心宕机了, 会不会影响到服务的正常调用

在dubbo的各个服务组件调用中中,什么地方用的是长连接,什么地方用的是短连接?

第三章 Dubbo入门案例(重点)

1. 服务注册中心准备

注册中心负责服务地址的注册与查找，服务提供者和消费者与注册中心交互。

Dubbo支持的服务注册中心有很多，比如zookeeper、redis、mysql等等，官方推荐使用 zookeeper 注册中心。

Zookeeper是Apacahe Hadoop的子项目，是一个树型的目录服务，支持变更推送，适合作为Dubbo服务的注册中心，可用于生产环境。

1.1 安装

将资料中的zookeeper-3.4.6.zip复制到一个没有中文，没有空格的目录，然后解压，即可得到zookeeper的软件

1.2 修改配置

进入到zookeeper的配置目录，复制zoo_sample.cfg为zoo.cfg
编辑zoo.cfg文件，修改dataDir的值为安装目录\\data这是zookeeper存储数据的位置

1.3 启动

进入安装路径的bin目录，双击zkServer.cmd即可启动zookeeper服务

2. 准备一个父工程

注意: 为了不影响我们的项目环境, 我们单独整一个工程来做

<?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.itheima</groupId>
    <artifactId>dubbo_parent</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.1.6.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- dubbo相关 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.6</version>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.32.Final</version>
        </dependency>
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.0.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.7</version>
        </dependency>
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 设置编译版本为1.8 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3. 服务提供者开发

3.1 创建一个web工程

一定需要转换成war的打包方式

<?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">  
  <parent> 
    <artifactId>dubbo_parent</artifactId>  
    <groupId>com.itheima</groupId>  
    <version>1.0-SNAPSHOT</version> 
  </parent>  
  <modelVersion>4.0.0</modelVersion>  
  <artifactId>dubbo_provider</artifactId>
  <packaging>war</packaging> 
</project>

3.2 创建service接口

/**
 * @description: 定义一个接口
 * @author: mryhl
 * @date: Created in 2020/10/13 16:24
 * @version: 1.0
 */
public interface HelloService {
   /**
    * @author mryhl
    * 传入参数,sayhello
    */
   String sayHello(String name);
}

3.3 创建service实现类

import com.itheima.service.HelloService;
import com.alibaba.dubbo.config.annotation.Service;

/**
 * @description: 实现接口
 * @author: mryhl
 * @date: Created in 2020/10/13 16:28
 * @version: 1.0
 * 引入阿里dubbo的service注解
 * 作用: 将当前类放入spring容器
 *      暴露一个服务到dubbo中
 */
@Service
public class HelloServiceImpl implements HelloService {
   @Override
   public String sayHello(String name) {
      return "welcome" + name ;
   }
}

3.4 加入spring-dubbo配置文件

applicationContext-dubbo.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:aop="http://www.springframework.org/schema/aop"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 1.当前服务的名称-->
    <dubbo:application name="dubbo_provider"></dubbo:application>

    <!-- 2.连接zookeeper注册中心地址-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>

    <!-- 3.指定rpc的具体通信协议和端口-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>

    <!-- 4.开启业务层包扫描
            1.扫描所有带@service注解的类交给ioc容器
            2.通过dubbo对外暴露服务
    -->
    <dubbo:annotation package="com.itheima.dubbo.service"></dubbo:annotation>
</beans>

3.5 加入web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns="http://java.sun.com/xml/ns/javaee"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   version="2.5">
   <!--配置spring环境-->
   <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:applicationContext-*.xml</param-value>
   </context-param>
   <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>
</web-app>

4. 服务消费者开发

4.1 创建一个web工程

<?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">  
  <parent> 
    <artifactId>dubbo_parent</artifactId>  
    <groupId>com.itheima</groupId>  
    <version>1.0-SNAPSHOT</version> 
  </parent>  
  <modelVersion>4.0.0</modelVersion>  
  <artifactId>dubbo_consumer</artifactId>
  <packaging>war</packaging> 
</project>

4.2 复制一个service接口

public interface HelloService {
   /**
    * @author mryhl
    * 传入参数,sayhello
    */
   String sayHello(String name);
}

4.3 创建controller类

import com.itheima.service.HelloService;
import com.alibaba.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @description:
 * @author: mryhl
 * @date: Created in 2020/10/13 17:05
 * @version: 1.1
 */
@Controller
public class HelloController {
   @Reference
   private HelloService helloService;
   @RequestMapping("/hello")
   @ResponseBody
   public String sayHello(String name){
      return helloService.sayHello(name);
   }  
   
}

4.4 加入spring-dubbo配置文件

springmvc.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:aop="http://www.springframework.org/schema/aop"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

       <!-- spring的注解扫描,让@Controller和@RequestMapping生效-->
    <context:component-scan base-package="com.itheima.dubbo.controller" />
    <!--注解驱动-->
    <mvc:annotation-driven />


    <!-- 1.当前服务的名称-->
    <dubbo:application name="dubbo_consumer" />

    <!-- 2.连接zookeeper注册中心地址-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" />

    <!-- 3.dubbo的注解扫描,创建service接口代理对象，实现RPC远程通信-->
    <dubbo:annotation package="com.itheima.dubbo.controller" />
</beans>

4.5 加入web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns="http://java.sun.com/xml/ns/javaee"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   version="2.5">
   <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:springmvc.xml</param-value>
      </init-param>
      <load-on-startup>4</load-on-startup>
   </servlet>

   <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/</url-pattern>
   </servlet-mapping>
</web-app>

5. 执行过程说明

6. Dubbo的两种部署方式

直接采用tomcat部署(推荐企业生产环境)

使用main方法直接启动spring环境(推荐开发测试阶段使用目的节省内存资源)

import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.IOException;
/**
 * @description:
 * @author: mryhl
 * @date: Created in 2020/10/13 19:50
 * @version: 1.1
 */
public class ProviderStart {
   public static void main(String[] args) throws IOException {
      ClassPathXmlApplicationContext act = new ClassPathXmlApplicationContext("applicationContext-dubbo.xml");
      // 启动容器
      act.start();
      // 阻塞线程,保证Spring环境一直处于运行状态
      System.in.read();

   }

第四章 Dubbo的使用细节(了解)

1. 包扫描

<!--服务提供者和服务消费者都需要配置包扫描，作用是扫描指定包(包括子包)下的类中的注解: @Service  @Refrences-->
<dubbo:annotation package="com.itheima.dubbo.controller" />

2. 协议

<!--
	在服务提供者一方配置，可以指定使用的协议名称和端口号。
	其中Dubbo支持的协议有：dubbo、rmi、hessian、http、webservice、rest、redis等。
-->
<dubbo:protocol name="dubbo" port="20880"/>

3. 启动时检查

<!--
    启动时检查, 配置在服务消费者一方，用于服务消费者在启动的时候主动检查服务提供者是否准备好提供服务
       如果配置为false, 代表不检查
       如果配置为true, 代表检查, 一旦检查到服务提供者未准备好, 就会直接抛异常
    建议在开发阶段将check值设置为false(默认)，在生产环境下改为true。
-->
<dubbo:consumer check="false"/>

4. 超时时间和重试机制(配置)

<!--配置在消费者端一方: 默认的超时时间是1s ，默认的重试次数是3次--> 
<dubbo:consumer timeout="5000000000000" retries="0"/>

第五章 Dubbo入门案例改进

1. 当前工程的问题

Service接口代码重复
两个工程中的Service必须完全一致, 这做起来其实很麻烦

改进思路: 将service接口单独做成一个模块, 然后让provider和consumer来引用

2. 工程改进

2.1 创建一个新的模块(接口)

<?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">
    <parent>
        <artifactId>dubbo_parent</artifactId>
        <groupId>com.itheima</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>dubbo_interface</artifactId>


</project>

2.2 从provider和consumer引入新模块

<dependencies>
  <dependency>
    <groupId>com.itheima</groupId>
    <artifactId>dubbo_interface</artifactId>
    <version>1.0-SNAPSHOT</version>
  </dependency>
</dependencies>

2.3 Dubbo下的标准maven模块划分

第六章 Dubbo监控中心(了解)

Dubbo给我们提供了一个UI界面的监控中心, 通过它可以观察到dubbo内部的详细信息

1. 安装

1.1 准备tomcat

准备一个没有使用过的tomcat(资料中有), 解压到一个没有中文和空格的路径

1.2 部署监控程序

将dubbo-admin.war程序部署到tomcat, 然后启动tomcat, 让程序解压

1.3 配置文件调整

如果zk的地址和端口没有修改过,这步无需操作; 如果修改了下面的文件, 则必须重启tomcat

2.使用

2.1 登录

打开浏览器，输入http://127.0.0.1:9999/dubbo-admin/ ，登录用户名和密码均为root, 登录成功可以见到下面的页面

2.2 使用

通过服务治理下服务提供者消费者可以观察具体应用的信息

第七章企业用户申请

1. 需求分析

1.1 需求说明

我们的平台, 除了后台管理系统之外, 其实还有一个供用户使用的前台系统, 具体页面如下

我们现在需要把这个前台系统也部署起来, 它的主要功能是完成企业的申请[ 对ss_company表做插入操作 ]

1.2 模型分析

2. 模块拆分

2.1 补充缺少的模块, 修改打包方式

新建四个模块,并将两个service和两个web模块结尾的模块调整为maven的web模块

2.2 建立包之间的依赖关系(略)

2.3 代码拆分

将当前system_service中的代码分到四个模块中

2.4 配置文件添加

3. dubbo环境加入

3.1添加dubbo的配置文件

服务提供方

在两个service模块中,添加dubbo的配置文件applicationContext-dubbo.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:aop="http://www.springframework.org/schema/aop"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--这个名字, 尽量跟项目名一致-->
    <dubbo:application name="export_company_service"/>
    <!--这个端口,不能重复-->
    <dubbo:protocol name="dubbo" port="20881"/>
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    <dubbo:annotation package="com.itheima.service"/>
</beans>

服务消费方

修改两个web模块中的dubbo的配置文件springmvc.xml,添加下面配置:

<!--这个名字, 尽量跟项目名一致-->
<dubbo:application name="export_manager_web"/>

<dubbo:consumer timeout="50000000" retries="0"/>
<dubbo:registry address="zookeeper://127.0.0.1:2181"/>
<dubbo:annotation package="com.itheima.web"/>

3.2 修改注解

将所有Service实现类上的@Service注解改为阿里的@Service注解
将所有下图所示所有类中的注入service的@Autowired注解改为阿里的@Reference

3.3 整合dubbo后, shiro的一个问题

现象: 在SaasRelm中, 使用@Refrence注入的userService为空

原因: Realm先于dubbo创建在，而创建的时候就会去dubbo中获取service对象, 所以获取不到

解决方案: 从Dubbo中获取userService获取后交给spring容器管理。SaasRelm使用的时候再从spring容器中获取。

1 创建一个工具类

package com.itheima.web.utils;

import com.alibaba.dubbo.config.annotation.Reference;
import com.itheima.service.system.UserService;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class SpringUtil implements ApplicationContextAware {

    @Reference
    private UserService userService;

    @Bean
    public UserService userService() {
        return userService;
    }

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (SpringUtil.applicationContext == null) {
            SpringUtil.applicationContext = applicationContext;
        }
    }

    //获取applicationContext
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    //通过name获取 Bean.
    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    //通过class获取Bean.
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    //通过name,以及Clazz返回指定的Bean
    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }
}

**2 修改SaasReam中获取service的方式

package com.itheima.web.realm;

import com.itheima.domain.system.Module;
import com.itheima.domain.system.User;
import com.itheima.service.system.UserService;
import com.itheima.web.utils.SpringUtil;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

import java.util.List;

public class SaasRealm extends AuthorizingRealm {


   /**
    * @description 用户授权
    * @author mryhl
    * @date 2020/10/11 16:15
    * @return simpleAuthorizationInfo 简单授权信息
    */
   @Override
   protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
      System.out.println("=====================授权=====================");
      UserService userService = (UserService) SpringUtil.getBean("userService");
      // 查询当前用户的权限信息
      User user = (User) principalCollection.getPrimaryPrincipal();
      List<Module> moduleList = userService.findModuleByUser(user);
      // 将信息传递到Shiro
      SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
      for (Module module : moduleList) {
         simpleAuthorizationInfo.addStringPermission(module.getName());
      }
      System.out.println(simpleAuthorizationInfo);
      return simpleAuthorizationInfo;
   }

   /**
    * @description 用户认证
    * @author mryhl
    * @date 2020/10/11 16:56
    * @return AuthenticationInfo 的实现类 SimpleAuthenticationInfo 简单认证信息
    */
   @Override
   protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
      // 进入方法标识
      System.out.println("=====================认证=====================");
      UserService userService = (UserService) SpringUtil.getBean("userService");
      // 强制类型转换
      UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;
      // 获取传入的email
      String email = usernamePasswordToken.getUsername();
      // 根据用户进行查询
      User user = userService.findByEmail(email);
      // 判断返回信息
      if (user==null) {
         // 返回空的简单身份认证信息,代表没有找到内容
         return new SimpleAuthenticationInfo();
      }else {
         /**
          * @author mryhl
          * SimpleAuthenticationInfo三个参数
          * Object principal 主角---->user
          * Object credentials  密码--->user.getPassword()
          * String realmName 当前realm的名称--->this.getName()
          */
         return new SimpleAuthenticationInfo(user,user.getPassword(),this.getName());
      }

   }
}

3.4 启动测试

开发环境下, 为了方便, 可以直接使用main方法启动两个service

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * @description:
 * @author: mryhl
 * @date: Created in 2020/10/13 20:47
 * @version: 1.1
 */
public class SystemStart {
   public static void main(String[] args) throws IOException {
      ClassPathXmlApplicationContext act =
            new ClassPathXmlApplicationContext("classpath*:spring/applicationContext-*.xml");

      act.start();

      System.in.read();
   }
}

public static void main(String[] args) throws IOException {
    ClassPathXmlApplicationContext act =
            new ClassPathXmlApplicationContext("classpath*:spring/applicationContext-*.xml");
    act.start();
    System.in.read();
}

4. 开发前台功能

4.1 添加页面

4.2 部署项目

4.3 企业申请页面代码分析

4.4 companyController开发

在export_portal_web模块的com.itheima.web.controller下建立下面的类

package com.itheima.web.controller;

import com.alibaba.dubbo.config.annotation.Reference;
import com.itheima.domain.company.Company;
import com.itheima.service.company.CompanyService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.UUID;

@Controller
public class CompanyController {

    @Reference
    private CompanyService companyService;

    @RequestMapping("/apply")
    @ResponseBody
    public String apply(Company company) {
        try {
            //设置企业ID和状态
            company.setId(UUID.randomUUID().toString());
            company.setState(0);

            //调用service保存
            companyService.save(company);

            return "1";
        } catch (Exception e) {
            e.printStackTrace();
            return "0";
        }
    }
}

Mr.YHL

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
dubboo框架

今日内容系统架构介绍Dubbo框架的介绍Dubbo入门案例Dubbo引入项目中第一章系统架构演变(了解)随着互联网的发展，网站应用的规模也在不断的扩大，进而导致系统架构也在不断的进行变化。从互联网早起到现在，系统架构大体经历了下面几个过程: 单体应用架构—>垂直应用架构—>分布式架构—>SOA架构--->微服务架构1. ...
复制链接

扫一扫