本文是《Android开发之深度项目设计探索》系列的第三篇，主要介绍的是 基于最新RxPermissions 类库的使用及源码分析，本系列历史文章：
《Android开发之深度项目设计探索（一）》
《Android开发之深度项目设计探索（二）》
Permission，这个单词翻译过来的意思有：允许、许可、权限。我们Android开发亲切的将其称为权限。
权限是一种安全机制。Android权限机制主要用于：限制应用程序内部某些具有限制特性的功能使用以及应用程序之间的组件访问。
在Android系统6.0版本（也就是 SdkVersion = 23）之前，权限的声明仅需要在清单配置文件中，通过标签uses-permission来声明应用，也就意味所需要的权限，如：
<uses-permission android:name="android.permission.CAMERA"/>
这行配置代码的意思意味着该应用允许使用CAMERA（照相机）权限；
由于时代的发展以及各种因素，谷歌Android技术团队出于安全角度这一原则设计考虑，在Android系统6.0版本开始，之后的版本提出了一些新概念，整理下来有以下几点：
概念一：权限分为两种、一种是普通权限；还有一种是危险权限
概念二：普通权限，直接在清单文件中配置声明即可
概念三：危险权限，谷歌觉得部分权限涉及到用户的隐私，因此必须明确告知用户应用需要那些权限，但是这样的危险权限需要用户手动授权
既然谷歌在新版本给我们带来了新概念和需要解决的问题，那么就需要解决这个权限问题：
那么这篇文章介绍的 RxPermissions-官方文档，这是一款基于Rxjava2的运行时权限解决方案，
这个库的minSdkVersion 最低不能低于11，也就是 "use this library your minSdkVersion must be >= 11"
在gradle导入最新版本的RxPermissions依赖：" implementation 'com.github.tbruyelle:rxpermissions:0.10.2' "
集成和使用步骤如下：
//这里的this就是Activity or Fragment instance
RxPermissions rxPermissions = new RxPermissions(this);
RxPermissions rxPermissions = new RxPermissions(this);
// 申请单个权限
rxPermissions.request(Manifest.permission.CAMERA).subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
if (aBoolean == true){
// 用户已经同意该权限
Log.i(TAG, "accept: CAMERA 权限成功");
}else {
// 用户拒绝权限
Log.i(TAG, "accept: CAMERA 权限失败");
}
}
});
获取多个权限方式有两种写法：
// 用户同时申请多个权限，方式一：
// 如果用户全部申请成功，才会返回true
// 如果用户有一个权限拒绝申请，那么就会返回失败
rxPermissions.requestEach(
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_CALENDAR,
Manifest.permission.READ_PHONE_STATE).
subscribe(new Consumer<Permission>() {
@Override
public void accept(Permission permission) throws Exception {
if (permission.granted) {
// 用户已经同意该权限
Log.d(TAG, permission.name + "用户授予权限");
} else if (permission.shouldShowRequestPermissionRationale) {
// 用户拒绝了该权限，没有选中『不再询问』（Never ask again）,那么下次再次启动时，还会提示请求权限的对话框
Log.d(TAG, permission.name + "用户拒绝权限——下次启动可以继续申请");
} else {
// ！！！注意！！！
// 用户拒绝了该权限，并且选中了『不再询问』
// 需要去 APP设置 里面去打开对应的申请权限
Log.d(TAG, permission.name + "用户拒绝权限——勾选了不在询问——提示用户后续去手动申请");
}
}
});
// 用户同时申请多个权限，方式二：
// 对应每个权限申请的操作
// 思考：
// 我们可以在应用启动之前也打开获取权限，然后记录每个权限是否申请成功，记录的方式可以通过sp存储状态
// 在需要权限的时候，首先判断SP存储的状态是否为权限授权成功，如果没有授权成功，那么就再次请求授权
rxPermissions.requestEachCombined(
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_CALENDAR,
Manifest.permission.READ_PHONE_STATE).
subscribe(new Consumer<Permission>() {
@Override
public void accept(Permission permission) throws Exception {
// 判断具体的对应权限
if (permission.name.equals(Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
if (permission.granted){
Log.i(TAG, "WRITE_EXTERNAL_STORAGE_accept: 权限申请成功");
}else {
Log.i(TAG, "WRITE_EXTERNAL_STORAGE_accept: 权限授权失败");
}
}
if (permission.name.equals(Manifest.permission.READ_PHONE_STATE)) {
if (permission.granted){
Log.i(TAG, "READ_PHONE_STATE: 权限申请成功");
}else {
Log.i(TAG, "READ_PHONE_STATE: 权限授权失败");
}
}
}
});
嗯，没错，基本上，这款框架的使用就已经介绍完了，是不是很简单优雅。
但是有一些细节我们需要注意，如该库的作者不建议我们在 onResume（）这个生命周期里面进行申请权限， RxPermissions-官方文档 也给了详细说明，
下面是源码解读
我们知道，Rxpermissions使用的第一步是在Activity中创建RxPermissions这个实例化对象。实际上，RxPermission采用的方式是利用了一个隐形的Fragment来请求权限，然后在回调中用RxJava进行数据的组装和转化，最后变成了布尔类型的数据回调回来。这个隐形的Fragment，就是类库中的RxPermissionsFragment，
public class RxPermissionsFragment extends Fragment {
private static final int PERMISSIONS_REQUEST_CODE = 42;
// Contains all the current permission requests.
// Once granted or denied, they are removed from it.
private Map<String, PublishSubject<Permission>> mSubjects = new HashMap<>();
private boolean mLogging;
public RxPermissionsFragment() {
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setRetainInstance(true);
}
@TargetApi(Build.VERSION_CODES.M)
void requestPermissions(@NonNull String[] permissions) {
requestPermissions(permissions, PERMISSIONS_REQUEST_CODE);
}
@TargetApi(Build.VERSION_CODES.M)
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode != PERMISSIONS_REQUEST_CODE) return;
boolean[] shouldShowRequestPermissionRationale = new boolean[permissions.length];
for (int i = 0; i < permissions.length; i++) {
shouldShowRequestPermissionRationale[i] = shouldShowRequestPermissionRationale(permissions[i]);
}
onRequestPermissionsResult(permissions, grantResults, shouldShowRequestPermissionRationale);
}
void onRequestPermissionsResult(String permissions[], int[] grantResults, boolean[] shouldShowRequestPermissionRationale) {
for (int i = 0, size = permissions.length; i < size; i++) {
log("onRequestPermissionsResult " + permissions[i]);
// Find the corresponding subject
PublishSubject<Permission> subject = mSubjects.get(permissions[i]);
if (subject == null) {
// No subject found
Log.e(RxPermissions.TAG, "RxPermissions.onRequestPermissionsResult invoked but didn't find the corresponding permission request.");
return;
}
mSubjects.remove(permissions[i]);
boolean granted = grantResults[i] == PackageManager.PERMISSION_GRANTED;
subject.onNext(new Permission(permissions[i], granted, shouldShowRequestPermissionRationale[i]));
subject.onComplete();
}
}
@TargetApi(Build.VERSION_CODES.M)
boolean isGranted(String permission) {
final FragmentActivity fragmentActivity = getActivity();
if (fragmentActivity == null) {
throw new IllegalStateException("This fragment must be attached to an activity.");
}
return fragmentActivity.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED;
}
@TargetApi(Build.VERSION_CODES.M)
boolean isRevoked(String permission) {
final FragmentActivity fragmentActivity = getActivity();
if (fragmentActivity == null) {
throw new IllegalStateException("This fragment must be attached to an activity.");
}
return fragmentActivity.getPackageManager().isPermissionRevokedByPolicy(permission, getActivity().getPackageName());
}
public void setLogging(boolean logging) {
mLogging = logging;
}
public PublishSubject<Permission> getSubjectByPermission(@NonNull String permission) {
return mSubjects.get(permission);
}
public boolean containsByPermission(@NonNull String permission) {
return mSubjects.containsKey(permission);
}
public void setSubjectForPermission(@NonNull String permission, @NonNull PublishSubject<Permission> subject) {
mSubjects.put(permission, subject);
}
void log(String message) {
if (mLogging) {
Log.d(RxPermissions.TAG, message);
}
}
}
可以看到，这个类继承了Fragment。然后在onCreate中并没有创建具体的UI布局，我们知道。Fragment具有属性retainInstance，默认值为false。 当设备旋转时，fragment会随托管activity一起销毁并重建。解决办法是：调用setRetainInstance(true)方法可保留fragment不会重新创建（例如旋转屏幕）
你可能会问，那这个隐形的Fragment又是在那里创建的？答案：创建的时机，是在创建RxPermissions的对象中，顺带创建了这个实例对象（通过构造方法实现）：下面是Rxpermissions这个类的构造方法以及部分函数源码：
public class RxPermissions {
static final String TAG = RxPermissions.class.getSimpleName();
static final Object TRIGGER = new Object();
@VisibleForTesting
Lazy<RxPermissionsFragment> mRxPermissionsFragment;
public RxPermissions(@NonNull final FragmentActivity activity) {
mRxPermissionsFragment = getLazySingleton(activity.getSupportFragmentManager());
}
public RxPermissions(@NonNull final Fragment fragment) {
mRxPermissionsFragment = getLazySingleton(fragment.getChildFragmentManager());
}
@NonNull
private Lazy<RxPermissionsFragment> getLazySingleton(@NonNull final FragmentManager fragmentManager) {
return new Lazy<RxPermissionsFragment>() {
private RxPermissionsFragment rxPermissionsFragment;
@Override
public synchronized RxPermissionsFragment get() {
if (rxPermissionsFragment == null) {
rxPermissionsFragment = getRxPermissionsFragment(fragmentManager);
}
return rxPermissionsFragment;
}
};
}
private RxPermissionsFragment getRxPermissionsFragment(@NonNull final FragmentManager fragmentManager) {
RxPermissionsFragment rxPermissionsFragment = findRxPermissionsFragment(fragmentManager);
boolean isNewInstance = rxPermissionsFragment == null;
if (isNewInstance) {
rxPermissionsFragment = new RxPermissionsFragment();
fragmentManager
.beginTransaction()
.add(rxPermissionsFragment, TAG)
.commitNow();
}
return rxPermissionsFragment;
}
//.............省略部分源码................
}
这个隐形的Fragment很重要，因为权限的申请与申请结果的回调都是在Fragment中完成的。基于此，开发人员才不需要为申请结果重写回调方法。
接着，是Rxpermissions基本使用的代码，也就是rxPermissions.request......，对应的源码如下：
/**
* Request permissions immediately, <b>must be invoked during initialization phase
* of your application</b>.
*/
@SuppressWarnings({"WeakerAccess", "unused"})
public Observable<Boolean> request(final String... permissions) {
return Observable.just(TRIGGER).compose(ensure(permissions));
}
/**
* Request permissions immediately, <b>must be invoked during initialization phase
* of your application</b>.
*/
@SuppressWarnings({"WeakerAccess", "unused"})
public Observable<Permission> requestEach(final String... permissions) {
return Observable.just(TRIGGER).compose(ensureEach(permissions));
}
/**
* Request permissions immediately, <b>must be invoked during initialization phase
* of your application</b>.
*/
public Observable<Permission> requestEachCombined(final String... permissions) {
return Observable.just(TRIGGER).compose(ensureEachCombined(permissions));
}
从中可以看到，上面使用的三种写法，最终是调到了
Observable.just(TRIGGER).compose(ensureEach(permissions));
static final Object TRIGGER = new Object();
通过源码可以看到，根据just操作符创建完Observable对象之后紧接着调用了compose()方法。
compose()操作符主要是将一个Observable对象（具体的数据类型）转换成另一个Observable（对应的数据类型）对象，我们发现此方法最终调用的是ensure(permissions)这个方法
public <T> ObservableTransformer<T, Boolean> ensure(final String... permissions) {
ObservableTransformer<T, Boolean> observableTransformer = new ObservableTransformer<T, Boolean>() {
@Override
public ObservableSource<Boolean> apply(Observable<T> o) {
Observable<Boolean> booleanObservable = request(o, permissions)
// Transform Observable<Permission> to Observable<Boolean>
.buffer(permissions.length)
.flatMap(new Function<List<Permission>, ObservableSource<Boolean>>() {
@Override
public ObservableSource<Boolean> apply(List<Permission> permissions) {
if (permissions.isEmpty()) {
// Occurs during orientation change, when the subject receives onComplete.
// In that case we don't want to propagate that empty list to the
// subscriber, only the onComplete.
return Observable.empty();
}
// Return true if all permissions are granted.
for (Permission p : permissions) {
if (!p.granted) {
return Observable.just(false);
}
}
return Observable.just(true);
}
});
return booleanObservable;
}
};
return observableTransformer;
}
这个buffer()的操作符作用是什么呢，它的作用是为了将一个序列的Observable<Permission>对象转换成Observable<List<Permission>>对象，
抛开Rxjava2常规的操作符除外，首先看下这段来自RxPermissions类库部分源码提供的自定义方法有：request(o, permissions)；源码还自定义了一个类：Permission，其中p.granted这种写法貌似就是类名.成员变量的操作，那我们就先看一眼Permission这个最基本的Java类
Permission源码如下：
public class Permission {
public final String name;
public final boolean granted;
public final boolean shouldShowRequestPermissionRationale;
public Permission(String name, boolean granted) {
this(name, granted, false);
}
public Permission(String name, boolean granted, boolean shouldShowRequestPermissionRationale) {
this.name = name;
this.granted = granted;
this.shouldShowRequestPermissionRationale = shouldShowRequestPermissionRationale;
}
public Permission(List<Permission> permissions) {
name = combineName(permissions);
granted = combineGranted(permissions);
shouldShowRequestPermissionRationale = combineShouldShowRequestPermissionRationale(permissions);
}
@Override
@SuppressWarnings("SimplifiableIfStatement")
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final Permission that = (Permission) o;
if (granted != that.granted) return false;
if (shouldShowRequestPermissionRationale != that.shouldShowRequestPermissionRationale)
return false;
return name.equals(that.name);
}
@Override
public int hashCode() {
int result = name.hashCode();
result = 31 * result + (granted ? 1 : 0);
result = 31 * result + (shouldShowRequestPermissionRationale ? 1 : 0);
return result;
}
@Override
public String toString() {
return "Permission{" +
"name='" + name + '\'' +
", granted=" + granted +
", shouldShowRequestPermissionRationale=" + shouldShowRequestPermissionRationale +
'}';
}
private String combineName(List<Permission> permissions) {
return Observable.fromIterable(permissions)
.map(new Function<Permission, String>() {
@Override
public String apply(Permission permission) throws Exception {
return permission.name;
}
}).collectInto(new StringBuilder(), new BiConsumer<StringBuilder, String>() {
@Override
public void accept(StringBuilder s, String s2) throws Exception {
if (s.length() == 0) {
s.append(s2);
} else {
s.append(", ").append(s2);
}
}
}).blockingGet().toString();
}
private Boolean combineGranted(List<Permission> permissions) {
return Observable.fromIterable(permissions)
.all(new Predicate<Permission>() {
@Override
public boolean test(Permission permission) throws Exception {
return permission.granted;
}
}).blockingGet();
}
private Boolean combineShouldShowRequestPermissionRationale(List<Permission> permissions) {
return Observable.fromIterable(permissions)
.any(new Predicate<Permission>() {
@Override
public boolean test(Permission permission) throws Exception {
return permission.shouldShowRequestPermissionRationale;
}
}).blockingGet();
}
}
这个类我们先放在这里，在看一眼类库自定义的request(o, permissions)这个方法的源码：
private Observable<Permission> request(final Observable<?> trigger, final String... permissions) {
if (permissions == null || permissions.length == 0) {
throw new IllegalArgumentException("RxPermissions.request/requestEach " +
"requires at least one input permission");
}
Observable<Permission> permissionObservable =
oneOf(trigger, pending(permissions))
.flatMap(new Function<Object, Observable<Permission>>() {
@Override
public Observable<Permission> apply(Object o) {
return requestImplementation(permissions);
}
});
return permissionObservable;
}
可以看到这个方法返回的对象是一个Observable< Permission >，内部逻辑首先判断permissions 是否为null，长度是否大于0，如果满足其中一个条件就抛异常；如果permissions 不为null，长度且大于0，在调用oneOf方法和pending( )方法来创建合并Observable对象。其中，oneOf（）和pending( )方法的函数如下：
private Observable<?> oneOf(Observable<?> trigger, Observable<?> pending) {
if (trigger == null) {
return Observable.just(TRIGGER);
}
return Observable.merge(trigger, pending);
}
private Observable<?> pending(final String... permissions) {
for (String p : permissions) {
if (!mRxPermissionsFragment.get().containsByPermission(p)) {
return Observable.empty();
}
}
return Observable.just(TRIGGER);
}
pending(final String... permissions)这个函数的主要功能有：
oneOf(Observable<?> trigger, Observable<?> pending)这个函数的主要是：
我们知道，request(o, permissions)最终是调用了requestImplementation(permissions);这个方法，下面就看下requestImplementation(permissions);方法的内部源码：
@TargetApi(Build.VERSION_CODES.M)
private Observable<Permission> requestImplementation(final String... permissions) {
List<Observable<Permission>> list = new ArrayList<>(permissions.length);
List<String> unrequestedPermissions = new ArrayList<>();
// In case of multiple permissions, we create an Observable for each of them.
// At the end, the observables are combined to have a unique response.
for (String permission : permissions) {
mRxPermissionsFragment.get().log("Requesting permission " + permission);
if (isGranted(permission)) {
// Already granted, or not Android M
// Return a granted Permission object.
list.add(Observable.just(new Permission(permission, true, false)));
continue;
}
if (isRevoked(permission)) {
// Revoked by a policy, return a denied Permission object.
list.add(Observable.just(new Permission(permission, false, false)));
continue;
}
PublishSubject<Permission> subject = mRxPermissionsFragment.get().getSubjectByPermission(permission);
// Create a new subject if not exists
if (subject == null) {
unrequestedPermissions.add(permission);
subject = PublishSubject.create();
mRxPermissionsFragment.get().setSubjectForPermission(permission, subject);
}
list.add(subject);
}
if (!unrequestedPermissions.isEmpty()) {
String[] unrequestedPermissionsArray = unrequestedPermissions.toArray(new String[unrequestedPermissions.size()]);
requestPermissionsFromFragment(unrequestedPermissionsArray);
}
return Observable.concat(Observable.fromIterable(list));
}
A：创建第一个集合（也就是源码的List<Observable<Permission>> list）保存已经申请的权限
B：创建第二个集合（也就是List<String> unrequestedPermissions）用来保存没有请求成功的权限
C：对具体申请的权限列表进行循环遍历：
D：在RxPermissionsFragment中，寻找是否已经存在对应的权限，如果不存在（subject == null），则创建PublishSubject对象，将其添加到unrequestedPermissions集合中，然后将subject对象保存在第一个集合中，
E：如果有未申请的权限，则进行权限的申请操作，也就是requestPermissionsFromFragment(unrequestedPermissionsArray);这个函数
F：利用第一个集合创建Observable对象，用concat操作符进行链接，最终返回一个Observable<Permission>对象
结论：
这个方法主要的操作就是，定义集合保存一次申请的所有权限。无论这个权限是已经申请，还是被撤销，还是未申请，最终都会保存到list这个集合中。在后续的操作中，才可以进行转换。
同时，定义集合用于保存未申请的权限，然后在循环结束之后进行未申请权限的申请。
因此，现在的关键就是requestPermissionsFromFragment(unrequestedPermissionsArray);这个函数，源码继续跟进：
@TargetApi(Build.VERSION_CODES.M)
void requestPermissionsFromFragment(String[] permissions) {
mRxPermissionsFragment.get().log("requestPermissionsFromFragment " + TextUtils.join(", ", permissions));
mRxPermissionsFragment.get().requestPermissions(permissions);
}
继续跟进：
@TargetApi(Build.VERSION_CODES.M)
void requestPermissions(@NonNull String[] permissions) {
requestPermissions(permissions, PERMISSIONS_REQUEST_CODE);
}
看到这里，最终是调用了requestPermissions(permissions, PERMISSIONS_REQUEST_CODE);，这个PERMISSIONS_REQUEST_CODE，的值是42，源码里面有。这个方法是Fragment提供的系统方法，那么回调的处理结果理所当然在RxPermissionsFragment中：
@TargetApi(Build.VERSION_CODES.M)
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode != PERMISSIONS_REQUEST_CODE) return;
boolean[] shouldShowRequestPermissionRationale = new boolean[permissions.length];
for (int i = 0; i < permissions.length; i++) {
shouldShowRequestPermissionRationale[i] = shouldShowRequestPermissionRationale(permissions[i]);
}
onRequestPermissionsResult(permissions, grantResults, shouldShowRequestPermissionRationale);
}
void onRequestPermissionsResult(String permissions[], int[] grantResults, boolean[] shouldShowRequestPermissionRationale) {
for (int i = 0, size = permissions.length; i < size; i++) {
log("onRequestPermissionsResult " + permissions[i]);
// Find the corresponding subject
PublishSubject<Permission> subject = mSubjects.get(permissions[i]);
if (subject == null) {
// No subject found
Log.e(RxPermissions.TAG, "RxPermissions.onRequestPermissionsResult invoked but didn't find the corresponding permission request.");
return;
}
mSubjects.remove(permissions[i]);
boolean granted = grantResults[i] == PackageManager.PERMISSION_GRANTED;
subject.onNext(new Permission(permissions[i], granted, shouldShowRequestPermissionRationale[i]));
subject.onComplete();
}
}
这段回调处理的源码意思主要有：
A：首先判断请求码，如果请求码不等于42，则直接返回
B：以权限列表的长度为size，创建一个boolean数组
C：循环遍历，看权限是否被永久拒绝了。这里会调用Fragment中的shouldShowRequestPermissionRationale()方法。这个方法如果权限申请成功会返回true；用户点击了不在提醒，且拒绝权限时，会返回false。
D：调用下面的重载方法
进入重载方法以后的操作有：
A：对权限列表进行循环操作。寻找相对应的：subject，也就是（ PublishSubject<Permission> subject = mSubjects.get(permissions[i]);）
B：如果没有对应的subject，则直接返回
C：如果有对应的subject，首先将集合中的permission的PublishSubject对象进行移除；接着判断是否申请成功；最后执行onNext( )返回相应的Permission对象
基本的源码分析就到这了。
评语：可以看到，RxPermissions这个库的主要逻辑就是在通过隐形的Fragment以及Rxjava2的操作符来进行实践的，通过合理搭配才让这个库使用起来比较方便。
如果这篇文章对你有帮助，希望各位看官留下宝贵的star，谢谢。
Ps:著作权归作者所有,转载请注明作者, 商业转载请联系作者获得授权，非商业转载请注明出处(开头或结尾请添加转载出处，添加原文url地址),文章请勿滥用,也希望大家尊重笔者的劳动成果。
微信关注我们
转载内容版权归作者及来源网站所有！
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。
Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。
Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。
Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。
扫码在手机上查看文章
扫描二维码，手机阅读更方便
有任何问题或合作意向欢迎联系我们
Email: 99873273@qq.com
QQ: 99873273