如果您对有没有办法从SSESpringuserwiseJava发出事件？和javaspringssm感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解有没有办法从SSESpringuserwise
如果您对有没有办法从 SSE Spring userwise Java 发出事件？和java spring ssm感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解有没有办法从 SSE Spring userwise Java 发出事件？的各种细节，并对java spring ssm进行深入的分析，此外还有关于Angular2 ngOnDestroy,发出事件、AWS S3：是 SSE-S3 信封加密吗？ SSE-S3 是否也采用信封加密？、C++ 和 OpenCV 中的 SSE 均值滤波器 1 - Mean_3_3_ref - 参考实现2 - Mean_3_3_scalar - 稍微优化的标量实现3 - Mean_3_3_scalar_opt - 进一步优化的标量实现4 - Mean_3_3_blur - 利用 OpenCV 的模糊功能5 - Mean_3_3_SSE - SSE 实施结果注意事项、Java - 有没有办法从 base64 输入确定文件大小？的实用技巧。
本文目录一览：- 有没有办法从 SSE Spring userwise Java 发出事件？（java spring ssm）
- Angular2 ngOnDestroy,发出事件
- AWS S3：是 SSE-S3 信封加密吗？ SSE-S3 是否也采用信封加密？
- C++ 和 OpenCV 中的 SSE 均值滤波器 1 - Mean_3_3_ref - 参考实现2 - Mean_3_3_scalar - 稍微优化的标量实现3 - Mean_3_3_scalar_opt - 进一步优化的标量实现4 - Mean_3_3_blur - 利用 OpenCV 的模糊功能5 - Mean_3_3_SSE - SSE 实施结果注意事项
- Java - 有没有办法从 base64 输入确定文件大小？
有没有办法从 SSE Spring userwise Java 发出事件？（java spring ssm）
如何解决有没有办法从 SSE Spring userwise Java 发出事件？
基本上我是使用 SSE Spring 发出数据。 新的 Eventsource() 正在侦听在浏览器上获取此数据的 url。 但问题是，
假设我以 ABC 的身份登录，另一个人以 XYZ 的身份登录，并且两者都收到了数据。如果数据属于 ABC，我想发出用户明智的信息，那么只有 ABC 应该接收。
if(typeof(EventSource) !== "undefined") {
var source = new EventSource(''/secure/newLeadChannel'');
source.onopen = function(){
console.log(''connection is opened.''+source.readyState);
};
source.onerror = function(){
console.log(''error: ''+source.readyState);
};
source.onmessage = function(datalist){
console.log("message: "+datalist.data);
//here the datalist.data is belong to any user,which should be a case
};
}
从后端
@GetMapping(path = "/newLeadChannel")
public SseEmitter newLeadEventEmitter() throws IOException {
SseEmitter sseEmitter= leadService.getemitter();
sseEmitter.onTimeout(()-> {
sseEmitter.complete();
});
return sseEmitter;
}
来自服务
emitter.send(userData); //This userdata should go the respective user
Angular2 ngOnDestroy,发出事件
@Output() rowInit = new EventEmitter();
@Output() rowDestroy = new EventEmitter();
ngAfterViewInit() {
this.rowInit.emit(this);
}
ngOnDestroy() {
console.log("I get called,but not emit :(,ngAfterViewInit works :)");
this.rowDestroy.emit(this);
}
import {EventEmitter} from 'angular2/core';
export class NotificationService {
onDestroyEvent: EventEmitter<string> = new EventEmitter();
constructor() {}
}
export class MyComponent implements OnDestroy {
constructor(service:NotificationService) {
this.service = service;
}
ngOnDestroy() {
this.service.onDestroyEvent.emit('component destroyed');
}
}
其他元素/组件可以在此EventEmitter上订阅以通知：
this.service.onDestroyEvent.subscribe(data => { ... });
希望它能帮到你,蒂埃里
AWS S3：是 SSE-S3 信封加密吗？ SSE-S3 是否也采用信封加密？
如何解决AWS S3：是 SSE-S3 信封加密吗？ SSE-S3 是否也采用信封加密？
这里是使用 S3 托管密钥 (SSE-S3) 的服务器端加密的加密流程
（这张图片来自Oreilly）
- 客户端选择要上传到 S3 的对象，并在此过程中指明 SSE-S3 的加密机制。
- S3 然后控制对象并使用 S3 生成的明文数据密钥对其进行加密。结果是对象的加密版本，然后将其存储在您选择的 S3 存储桶中。
- 用于加密对象的明文数据密钥随后使用 S3 主密钥进行加密，从而生成密钥的加密版本。这个现在加密的密钥也存储在 S3 上，并与加密的数据对象关联。最后，明文数据密钥在 S3 中从内存中删除。
如您所见，SSE-S3 使用唯一的数据密钥来加密对象，而不是主密钥。
听说SSE-KMS是信封加密，我的问题是：
SSE-S3 是否也采用信封加密？
参考
- Stack Overflow: Does AWS KMS use envelope encryption?
- AWS KMS Envelope Encryption
解决方法
AWS Encryption-At-Rest（服务器端加密）使用 Envelope Encryption，无论使用什么密钥。不仅适用于 S3，适用于 AWS 的每项服务。 Here 是一个很好的博客。
唯一的区别是谁管理数据密钥和加密密钥。
- SSE-S3 两个密钥都由 AWS 管理
- SSE-KMS 我们管理 CMK，而 AWS 管理数据密钥。让我们可以更好地控制轮换、访问等。
- SSE-C 我们同时管理加密密钥和数据密钥（我们可以选择不使用数据密钥而是使用相同的密钥），我们提供数据密钥和算法，AWS 为我们加密，我们需要跟踪哪个键用于哪个对象。
C++ 和 OpenCV 中的 SSE 均值滤波器 1 - Mean_3_3_ref - 参考实现2 - Mean_3_3_scalar - 稍微优化的标量实现3 - Mean_3_3_scalar_opt - 进一步优化的标量实现4 - Mean_3_3_blur - 利用 OpenCV 的模糊功能5 - Mean_3_3_SSE - SSE 实施结果注意事项
如何解决C++ 和 OpenCV 中的 SSE 均值滤波器 1 - Mean_3_3_ref - 参考实现2 - Mean_3_3_scalar - 稍微优化的标量实现3 - Mean_3_3_scalar_opt - 进一步优化的标量实现4 - Mean_3_3_blur - 利用 OpenCV 的模糊功能5 - Mean_3_3_SSE - SSE 实施结果注意事项？
我想修改 OpenCV 均值过滤器的代码以使用英特尔内在函数。我是 SSE 新手，我真的不知道从哪里开始。在网上查了很多资源，都没有成功。
这是程序：
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
using namespace cv;
using namespace std;
int main()
{
int A[3][3] = { { 1,1,1 },{ 1,1 } };
int c = 0;
int d = 0;
Mat var1 = imread("images.jpg",1);
Mat var2(var1.rows,var1.cols,CV_8UC3,Scalar(0,0));
for (int i = 0; i < var1.rows; i++)
{
var2.at<Vec3b>(i,0) = var1.at<Vec3b>(i,0);
var2.at<Vec3b>(i,var1.cols - 1) = var1.at<Vec3b>(i,var1.cols - 1);
}
for (int i = 0; i < var1.cols; i++)
{
var2.at<Vec3b>(0,i) = var1.at<Vec3b>(0,i);
var2.at<Vec3b>(var1.rows - 1,i) = var1.at<Vec3b>(var1.rows - 1,i);
}
for (int i = 0; i < var1.rows; i++) {
for (int j = 0; j < var1.cols; j++)
{
c = 0;
for (int m = i; m < var1.rows; m++,c++)
{
if (c < 3)
{
d = 0;
for (int n = j; n < var1.cols; n++,d++)
{
if (d < 3)
{
if ((i + 1) < var1.rows && (j + 1) < var1.cols)
{
var2.at<Vec3b>(i + 1,j + 1)[0] += var1.at<Vec3b>(m,n)[0] * A[m - i][n - j] / 9;
var2.at<Vec3b>(i + 1,j + 1)[1] += var1.at<Vec3b>(m,n)[1] * A[m - i][n - j] / 9;
var2.at<Vec3b>(i + 1,j + 1)[2] += var1.at<Vec3b>(m,n)[2] * A[m - i][n - j] / 9;
}
}
}
}
}
}
}
imshow("window1",var1);
imshow("window2",var2);
waitKey(0);
return(0);
}
我觉得困难的部分是理解如何转换最里面的 2 个循环，其中计算平均值。任何帮助将不胜感激。
解决方法
只是为了好玩，我认为从简单的 3x3 均值滤波器实现开始，然后逐步优化它，最终实现 SIMD (SSE)，测量每个阶段的吞吐量改进可能会很有趣。
>1 - Mean_3_3_ref - 参考实现
这只是一个简单的标量实现，我们将其用作吞吐量和验证进一步实现的基准：
void Mean_3_3_ref(const Mat &image_in,Mat &image_out)
{
for (int y = 1; y < image_in.rows - 1; ++y)
{
for (int x = 1; x < image_in.cols - 1; ++x)
{
for (int c = 0; c < 3; ++c)
{
image_out.at<Vec3b>(y,x)[c] = (image_in.at<Vec3b>(y - 1,x - 1)[c] +
image_in.at<Vec3b>(y - 1,x )[c] +
image_in.at<Vec3b>(y - 1,x + 1)[c] +
image_in.at<Vec3b>(y,x - 1)[c] +
image_in.at<Vec3b>(y,x )[c] +
image_in.at<Vec3b>(y,x + 1)[c] +
image_in.at<Vec3b>(y + 1,x - 1)[c] +
image_in.at<Vec3b>(y + 1,x )[c] +
image_in.at<Vec3b>(y + 1,x + 1)[c] + 4) / 9;
}
}
}
}
2 - Mean_3_3_scalar - 稍微优化的标量实现
在对连续列求和时利用冗余——我们保存最后两列的总和，以便我们在每次迭代时只需要计算一个新的列总和（每个通道）：
void Mean_3_3_scalar(const Mat &image_in,Mat &image_out)
{
for (int y = 1; y < image_in.rows - 1; ++y)
{
int r_1,g_1,b_1;
int r0,g0,b0;
int r1,g1,b1;
r_1 = g_1 = b_1 = 0;
r0 = g0 = b0 = 0;
for (int yy = y - 1; yy <= y + 1; ++yy)
{
r_1 += image_in.at<Vec3b>(yy,0)[0];
g_1 += image_in.at<Vec3b>(yy,0)[1];
b_1 += image_in.at<Vec3b>(yy,0)[2];
r0 += image_in.at<Vec3b>(yy,1)[0];
g0 += image_in.at<Vec3b>(yy,1)[1];
b0 += image_in.at<Vec3b>(yy,1)[2];
}
for (int x = 1; x < image_in.cols - 1; ++x)
{
r1 = g1 = b1 = 0;
for (int yy = y - 1; yy <= y + 1; ++yy)
{
r1 += image_in.at<Vec3b>(yy,x + 1)[0];
g1 += image_in.at<Vec3b>(yy,x + 1)[1];
b1 += image_in.at<Vec3b>(yy,x + 1)[2];
}
image_out.at<Vec3b>(y,x)[0] = (r_1 + r0 + r1 + 4) / 9;
image_out.at<Vec3b>(y,x)[1] = (g_1 + g0 + g1 + 4) / 9;
image_out.at<Vec3b>(y,x)[2] = (b_1 + b0 + b1 + 4) / 9;
r_1 = r0;
g_1 = g0;
b_1 = b0;
r0 = r1;
g0 = g1;
b0 = b1;
}
}
}
3 - Mean_3_3_scalar_opt - 进一步优化的标量实现
根据 Mean_3_3_scalar，但也通过缓存指向我们正在处理的每一行的指针来消除 OpenCV 开销：
void Mean_3_3_scalar_opt(const Mat &image_in,Mat &image_out)
{
for (int y = 1; y < image_in.rows - 1; ++y)
{
const uint8_t * const input_1 = image_in.ptr(y - 1);
const uint8_t * const input0 = image_in.ptr(y);
const uint8_t * const input1 = image_in.ptr(y + 1);
uint8_t * const output = image_out.ptr(y);
int r_1 = input_1[0] + input0[0] + input1[0];
int g_1 = input_1[1] + input0[1] + input1[1];
int b_1 = input_1[2] + input0[2] + input1[2];
int r0 = input_1[3] + input0[3] + input1[3];
int g0 = input_1[4] + input0[4] + input1[4];
int b0 = input_1[5] + input0[5] + input1[5];
for (int x = 1; x < image_in.cols - 1; ++x)
{
int r1 = input_1[x * 3 + 3] + input0[x * 3 + 3] + input1[x * 3 + 3];
int g1 = input_1[x * 3 + 4] + input0[x * 3 + 4] + input1[x * 3 + 4];
int b1 = input_1[x * 3 + 5] + input0[x * 3 + 5] + input1[x * 3 + 5];
output[x * 3 ] = (r_1 + r0 + r1 + 4) / 9;
output[x * 3 + 1] = (g_1 + g0 + g1 + 4) / 9;
output[x * 3 + 2] = (b_1 + b0 + b1 + 4) / 9;
r_1 = r0;
g_1 = g0;
b_1 = b0;
r0 = r1;
g0 = g1;
b0 = b1;
}
}
}
4 - Mean_3_3_blur - 利用 OpenCV 的模糊功能
OpenCV 有一个名为 blur 的函数，它基于函数 boxFilter，它只是均值过滤器的另一个名称。由于 OpenCV 代码多年来已经进行了大量优化（在许多情况下使用 SIMD），让我们看看这是否对我们的标量代码有很大的改进：
void Mean_3_3_blur(const Mat &image_in,Mat &image_out)
{
blur(image_in,image_out,Size(3,3));
}
5 - Mean_3_3_SSE - SSE 实施
这是一个相当高效的 SIMD 实现。它使用与上述标量代码相同的技术来消除处理连续像素时的冗余：
#include <tmmintrin.h> // Note: requires SSSE3 (aka MNI)
inline void Load2(const ssize_t offset,const uint8_t* const src,__m128i& vh,__m128i& vl)
{
const __m128i v = _mm_loadu_si128((__m128i *)(src + offset));
vh = _mm_unpacklo_epi8(v,_mm_setzero_si128());
vl = _mm_unpackhi_epi8(v,_mm_setzero_si128());
}
inline void Store2(const ssize_t offset,uint8_t* const dest,const __m128i vh,const __m128i vl)
{
__m128i v = _mm_packus_epi16(vh,vl);
_mm_storeu_si128((__m128i *)(dest + offset),v);
}
template <int SHIFT> __m128i ShiftL(const __m128i v0,const __m128i v1) { return _mm_alignr_epi8(v1,v0,SHIFT * sizeof(short)); }
template <int SHIFT> __m128i ShiftR(const __m128i v0,16 - SHIFT * sizeof(short)); }
template <int CHANNELS> void Mean_3_3_SSE_Impl(const Mat &image_in,Mat &image_out)
{
const int nx = image_in.cols;
const int ny = image_in.rows;
const int kx = 3 / 2; // x,y borders
const int ky = 3 / 2;
const int kScale = 3 * 3; // scale factor = total number of pixels in sum
const __m128i vkScale = _mm_set1_epi16((32768 + kScale / 2) / kScale);
const int nx0 = ((nx + kx) * CHANNELS + 15) & ~15; // round up total width to multiple of 16
int x,y;
for (y = ky; y < ny - ky; ++y)
{
const uint8_t * const input_1 = image_in.ptr(y - 1);
const uint8_t * const input0 = image_in.ptr(y);
const uint8_t * const input1 = image_in.ptr(y + 1);
uint8_t * const output = image_out.ptr(y);
__m128i vsuml_1,vsumh0,vsuml0;
__m128i vh,vl;
vsuml_1 = _mm_set1_epi16(0);
Load2(0,input_1,vsuml0);
Load2(0,input0,vh,vl);
vsumh0 = _mm_add_epi16(vsumh0,vh);
vsuml0 = _mm_add_epi16(vsuml0,vl);
Load2(0,input1,vl);
for (x = 0; x < nx0; x += 16)
{
__m128i vsumh1,vsuml1,vsumh,vsuml;
Load2((x + 16),vsumh1,vsuml1);
Load2((x + 16),vl);
vsumh1 = _mm_add_epi16(vsumh1,vh);
vsuml1 = _mm_add_epi16(vsuml1,vl);
Load2((x + 16),vl);
vsumh = _mm_add_epi16(vsumh0,ShiftR<CHANNELS>(vsuml_1,vsumh0));
vsuml = _mm_add_epi16(vsuml0,ShiftR<CHANNELS>(vsumh0,vsuml0));
vsumh = _mm_add_epi16(vsumh,ShiftL<CHANNELS>(vsumh0,vsuml0));
vsuml = _mm_add_epi16(vsuml,ShiftL<CHANNELS>(vsuml0,vsumh1));
// round mean
vsumh = _mm_mulhrs_epi16(vsumh,vkScale);
vsuml = _mm_mulhrs_epi16(vsuml,vkScale);
Store2(x,output,vsuml);
vsuml_1 = vsuml0;
vsumh0 = vsumh1;
vsuml0 = vsuml1;
}
}
}
void Mean_3_3_SSE(const Mat &image_in,Mat &image_out)
{
const int channels = image_in.channels();
switch (channels)
{
case 1:
Mean_3_3_SSE_Impl<1>(image_in,image_out);
break;
case 3:
Mean_3_3_SSE_Impl<3>(image_in,image_out);
break;
default:
throw("Unsupported format.");
break;
}
}
结果
我在 2.4 GHz 的第 8 代酷睿 i9（MacBook Pro 16,1）上对上述所有实现进行了基准测试，图像大小为 2337 行 x 3180 列。编译器是 Apple clang 版本 12.0.5 (clang-1205.0.22.9)，唯一的优化开关是 -O3。 OpenCV 版本为 4.5.0（通过 Homebrew）。 （注意：我验证了 Mean_3_3_blur 的 cv::blur 函数被分派到 AVX2 实现。）结果：
Mean_3_3_ref 62153 µs
Mean_3_3_scalar 41144 µs = 1.51062x
Mean_3_3_scalar_opt 26238 µs = 2.36882x
Mean_3_3_blur 20121 µs = 3.08896x
Mean_3_3_SSE 4838 µs = 12.84680x
注意事项
-
我在所有实现中都忽略了边框像素 - 如果需要，可以使用原始图像中的像素或使用其他形式的边缘像素处理来填充这些像素。
-
代码不是“工业实力”——它只是为了基准测试而编写的。
-
还有一些可能的优化，例如使用更宽的 SIMD（AVX2、AVX512）、利用连续行之间的冗余等 - 这些留给读者作为练习。
-
SSE 实施速度最快，但代价是增加了复杂性、降低了可维护性和降低了可移植性。
-
OpenCV
blur函数提供第二好的性能，如果满足吞吐量要求，它可能应该是首选解决方案 - 这是最简单的解决方案，简单就是好的。
Java - 有没有办法从 base64 输入确定文件大小？
如何解决Java - 有没有办法从 base64 输入确定文件大小？
我们有一个 java 程序，其中输入是文件的 base64 字符串版本。文件将根据其大小进行不同的处理，因此我们必须找到一种方法根据其 base64 输入确定其大小。
有没有办法做到这一点？我正在考虑从 base64 重新创建文件然后获取大小，但这意味着必须暂时存储它。我们不想那样。最好的方法是什么？
我们使用的是 Java 8
解决方法
基本上，是的。在基础上，Base64 使用 4 个字符编码 3 个字节。但是，您必须解决另外两个主要问题：
- Base64 有时会分成几行；规范说空格很好，必须忽略。 “新行”是一个字符（有时是两个），因此不能被计算在内。
- 如果文件不是 3 的精确倍数怎么办？ Base64 使用填充算法处理此问题。您总是以 4 个为一组获得 Base64 字符，但最后一组 4 个字符可能只编码 1 或 2 个字节，而不是通常的 3 个。
=符号用于填充。
这两个问题都可以很容易地解决：
遍历一个字符串并增加一个计数器并不难除非字符串中那个位置的字符是空格。
然后乘以 3，再除以 4。
如果字符串以 == 结尾，则减去 2。如果以 = 结尾，则减 1。
您可以在循环中计算 = 符号。
int countBase64Size(String in) {
int count = 0;
int pad = 0;
for (int i = 0; i < in.length(); i++) {
char c = in.charAt(i);
if (c == ''='') pad++;
if (!Character.isWhitespace(c)) count++;
}
return (count * 3 / 4) - pad;
}
关于有没有办法从 SSE Spring userwise Java 发出事件？和java spring ssm的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于Angular2 ngOnDestroy,发出事件、AWS S3：是 SSE-S3 信封加密吗？ SSE-S3 是否也采用信封加密？、C++ 和 OpenCV 中的 SSE 均值滤波器 1 - Mean_3_3_ref - 参考实现2 - Mean_3_3_scalar - 稍微优化的标量实现3 - Mean_3_3_scalar_opt - 进一步优化的标量实现4 - Mean_3_3_blur - 利用 OpenCV 的模糊功能5 - Mean_3_3_SSE - SSE 实施结果注意事项、Java - 有没有办法从 base64 输入确定文件大小？等相关知识的信息别忘了在本站进行查找喔。
本文标签：
