友情提示：
这篇文章的好几个工具类都很长，所以建议阅读的时候用拖拽条或者是目录，别打开，不然会绝望。
生成微信二维码
1、准备工作
1、注册
2、邮箱激活
3、完善开发者资料
4、开发者资质认证
准备营业执照，1-2个工作日审批、300元
5、创建网站应用
提交审核，7个工作日审批
和微信端对接，忙完后微信端会给你3个参数。当然下面这个是“尚硅谷”的，可别随便用，不然钱跑到这个账户，概不负责。
redirect_url 回调接口是自己在微信端写死的
网址:微信开放平台
网站应用微信登录开发指南：准备工作 | 微信开放文档
1.application.properties添加配置
2.引入依赖
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</dependency>
<!--gson-->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>3.utils包下创建俩个工具类ConstantPropertiesUtil 和 HttpClientUtils
InitializingBean接口为bean提供了属性初始化后的处理方法，它只有一个afterPropertiesSet方法，凡是继承该接口的类，在bean的属性初始化后都会执行该方法。
@Component
//@PropertySource("classpath:application.properties")
public class ConstantPropertiesUtil implements InitializingBean {
@Value("${wx.open.app_id}")
private String appId;
@Value("${wx.open.app_secret}")
private String appSecret;
@Value("${wx.open.redirect_url}")
private String redirectUrl;
public static String WX_OPEN_APP_ID;
public static String WX_OPEN_APP_SECRET;
public static String WX_OPEN_REDIRECT_URL;
@Override
public void afterPropertiesSet() throws Exception {
WX_OPEN_APP_ID = appId;
WX_OPEN_APP_SECRET = appSecret;
WX_OPEN_REDIRECT_URL = redirectUrl;
}
}HttpClientUtils，这个工具类是真的长，看着好碍眼啊
public class HttpClientUtils {
public static final int connTimeout=10000;
public static final int readTimeout=10000;
public static final String charset="UTF-8";
private static HttpClient client = null;
static {
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
cm.setMaxTotal(128);
cm.setDefaultMaxPerRoute(128);
client = HttpClients.custom().setConnectionManager(cm).build();
}
public static String postParameters(String url, String parameterStr) throws ConnectTimeoutException, SocketTimeoutException, Exception{
return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
}
public static String postParameters(String url, String parameterStr,String charset, Integer connTimeout, Integer readTimeout) throws ConnectTimeoutException, SocketTimeoutException, Exception{
return post(url,parameterStr,"application/x-www-form-urlencoded",charset,connTimeout,readTimeout);
}
public static String postParameters(String url, Map<String, String> params) throws ConnectTimeoutException,
SocketTimeoutException, Exception {
return postForm(url, params, null, connTimeout, readTimeout);
}
public static String postParameters(String url, Map<String, String> params, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
SocketTimeoutException, Exception {
return postForm(url, params, null, connTimeout, readTimeout);
}
public static String get(String url) throws Exception {
return get(url, charset, null, null);
}
public static String get(String url, String charset) throws Exception {
return get(url, charset, connTimeout, readTimeout);
}
/**
* 发送一个 Post 请求, 使用指定的字符集编码.
*
* @param url
* @param body RequestBody
* @param mimeType 例如 application/xml "application/x-www-form-urlencoded" a=1&b=2&c=3
* @param charset 编码
* @param connTimeout 建立链接超时时间,毫秒.
* @param readTimeout 响应超时时间,毫秒.
* @return ResponseBody, 使用指定的字符集编码.
* @throws ConnectTimeoutException 建立链接超时异常
* @throws SocketTimeoutException 响应超时
* @throws Exception
*/
public static String post(String url, String body, String mimeType,String charset, Integer connTimeout, Integer readTimeout)
throws ConnectTimeoutException, SocketTimeoutException, Exception {
HttpClient client = null;
HttpPost post = new HttpPost(url);
String result = "";
try {
if (StringUtils.isNotBlank(body)) {
HttpEntity entity = new StringEntity(body, ContentType.create(mimeType, charset));
post.setEntity(entity);
}
// 设置参数
Builder customReqConf = RequestConfig.custom();
if (connTimeout != null) {
customReqConf.setConnectTimeout(connTimeout);
}
if (readTimeout != null) {
customReqConf.setSocketTimeout(readTimeout);
}
post.setConfig(customReqConf.build());
HttpResponse res;
if (url.startsWith("https")) {
// 执行 Https 请求.
client = createSSLInsecureClient();
res = client.execute(post);
} else {
// 执行 Http 请求.
client = HttpClientUtils.client;
res = client.execute(post);
}
result = IOUtils.toString(res.getEntity().getContent(), charset);
} finally {
post.releaseConnection();
if (url.startsWith("https") && client != null&& client instanceof CloseableHttpClient) {
((CloseableHttpClient) client).close();
}
}
return result;
}
/**
* 提交form表单
*
* @param url
* @param params
* @param connTimeout
* @param readTimeout
* @return
* @throws ConnectTimeoutException
* @throws SocketTimeoutException
* @throws Exception
*/
public static String postForm(String url, Map<String, String> params, Map<String, String> headers, Integer connTimeout,Integer readTimeout) throws ConnectTimeoutException,
SocketTimeoutException, Exception {
HttpClient client = null;
HttpPost post = new HttpPost(url);
try {
if (params != null && !params.isEmpty()) {
List<NameValuePair> formParams = new ArrayList<NameValuePair>();
Set<Entry<String, String>> entrySet = params.entrySet();
for (Entry<String, String> entry : entrySet) {
formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formParams, Consts.UTF_8);
post.setEntity(entity);
}
if (headers != null && !headers.isEmpty()) {
for (Entry<String, String> entry : headers.entrySet()) {
post.addHeader(entry.getKey(), entry.getValue());
}
}
// 设置参数
Builder customReqConf = RequestConfig.custom();
if (connTimeout != null) {
customReqConf.setConnectTimeout(connTimeout);
}
if (readTimeout != null) {
customReqConf.setSocketTimeout(readTimeout);
}
post.setConfig(customReqConf.build());
HttpResponse res = null;
if (url.startsWith("https")) {
// 执行 Https 请求.
client = createSSLInsecureClient();
res = client.execute(post);
} else {
// 执行 Http 请求.
client = HttpClientUtils.client;
res = client.execute(post);
}
return IOUtils.toString(res.getEntity().getContent(), "UTF-8");
} finally {
post.releaseConnection();
if (url.startsWith("https") && client != null
&& client instanceof CloseableHttpClient) {
((CloseableHttpClient) client).close();
}
}
}
/**
* 发送一个 GET 请求
*
* @param url
* @param charset
* @param connTimeout 建立链接超时时间,毫秒.
* @param readTimeout 响应超时时间,毫秒.
* @return
* @throws ConnectTimeoutException 建立链接超时
* @throws SocketTimeoutException 响应超时
* @throws Exception
*/
public static String get(String url, String charset, Integer connTimeout,Integer readTimeout)
throws ConnectTimeoutException,SocketTimeoutException, Exception {
HttpClient client = null;
HttpGet get = new HttpGet(url);
String result = "";
try {
// 设置参数
Builder customReqConf = RequestConfig.custom();
if (connTimeout != null) {
customReqConf.setConnectTimeout(connTimeout);
}
if (readTimeout != null) {
customReqConf.setSocketTimeout(readTimeout);
}
get.setConfig(customReqConf.build());
HttpResponse res = null;
if (url.startsWith("https")) {
// 执行 Https 请求.
client = createSSLInsecureClient();
res = client.execute(get);
} else {
// 执行 Http 请求.
client = HttpClientUtils.client;
res = client.execute(get);
}
result = IOUtils.toString(res.getEntity().getContent(), charset);
} finally {
get.releaseConnection();
if (url.startsWith("https") && client != null && client instanceof CloseableHttpClient) {
((CloseableHttpClient) client).close();
}
}
return result;
}
/**
* 从 response 里获取 charset
*
* @param ressponse
* @return
*/
@SuppressWarnings("unused")
private static String getCharsetFromResponse(HttpResponse ressponse) {
// Content-Type:text/html; charset=GBK
if (ressponse.getEntity() != null && ressponse.getEntity().getContentType() != null && ressponse.getEntity().getContentType().getValue() != null) {
String contentType = ressponse.getEntity().getContentType().getValue();
if (contentType.contains("charset=")) {
return contentType.substring(contentType.indexOf("charset=") + 8);
}
}
return null;
}
/**
* 创建 SSL连接
* @return
* @throws GeneralSecurityException
*/
private static CloseableHttpClient createSSLInsecureClient() throws GeneralSecurityException {
try {
SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
public boolean isTrusted(X509Certificate[] chain,String authType) throws CertificateException {
return true;
}
}).build();
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {
@Override
public boolean verify(String arg0, SSLSession arg1) {
return true;
}
@Override
public void verify(String host, SSLSocket ssl)
throws IOException {
}
@Override
public void verify(String host, X509Certificate cert)
throws SSLException {
}
@Override
public void verify(String host, String[] cns,
String[] subjectAlts) throws SSLException {
}
});
return HttpClients.custom().setSSLSocketFactory(sslsf).build();
} catch (GeneralSecurityException e) {
throw e;
}
}
public static void main(String[] args) {
try {
String str= post("https://localhost:443/ssl/test.shtml","name=12&page=34","application/x-www-form-urlencoded", "UTF-8", 10000, 10000);
//String str= get("https://localhost:443/ssl/test.shtml?name=12&page=34","GBK");
/*Map<String,String> map = new HashMap<String,String>();
map.put("name", "111");
map.put("page", "222");
String str= postForm("https://localhost:443/ssl/test.shtml",map,null, 10000, 10000);*/
System.out.println(str);
} catch (ConnectTimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SocketTimeoutException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}2、正式逻辑代码部分
controller层直接返回微信登录的参数
这里有个很巧妙的地方，我们把微信端返给我们的3个参数是配置在了配置文件中，但是我们在ConstantPropertiesUtil里做了一些处理，就可以用这种静态常量的方式获取到这3个参数了，逼格满满
/**
* 获取微信登录参数
*/
@GetMapping("getLoginParam")
@ResponseBody
public R genQrConnect() throws UnsupportedEncodingException {
//返给前端的微信参数封装到map
//可以是小写的"utf-8"
String redirectUri = URLEncoder.encode(ConstantPropertiesUtil.WX_OPEN_REDIRECT_URL, "UTF-8");
Map<String, Object> map = new HashMap<>();
map.put("appid", ConstantPropertiesUtil.WX_OPEN_APP_ID);
map.put("redirectUri",redirectUri);//确认登录后的重定向地址，并携带code
map.put("scope", "snsapi_login");//固定的
map.put("state", System.currentTimeMillis()+"");//可以不传，但是推荐传
return R.ok().data(map);
}| 参数 | 是否必须 | 说明 |
|---|---|---|
| appid | 是 | 应用唯一标识 |
| redirect_uri | 是 | 请使用urlEncode（编码）对链接进行处理，回调地址 |
| response_type | 是 | 填code |
| scope | 是 | 应用授权作用域，拥有多个作用域用逗号（,）分隔，网页应用目前仅填写snsapi_login即 |
| state | 否 | 用于保持请求和回调的状态，授权请求后原样带回给第三方。该参数可用于防止csrf攻击（跨站请求伪造攻击），建议第三方带上该参数，可设置为简单的随机数加session进行校验 |
因为按照老师的话来说，要想凭空生成一张二维码，无非就是俩步骤。
第一引入一个js文件，因为在vue文件中不能直接使用<script>标签引入，所以就用这样的方式写在
mounted()钩子函数里了
//初始化微信js
const script = document.createElement("script");
script.type = "text/javascript";
script.src =
"https://res.wx.qq.com/connect/zh_CN/htmledition/js/wxLogin.js";
document.body.appendChild(script);第二从后台请求刚刚写的那个controller里的方法，拿到微信登录的参数，
<div id="weixinLogin"></div> weixinApi.getLoginParam().then((response) => {
var obj = new WxLogin({
self_redirect: true,
id: "weixinLogin", // 需要显示的容器id
appid: response.data.appid, // 公众号appid wx*******
scope: response.data.scope, // 网页默认即可
redirect_uri: response.data.redirectUri, // 授权成功后回调的url
state: response.data.state, // 可设置为简单的随机数加session用来校验
style: "black", // 提供"black"、"white"可选。二维码的样式
href: "", // 外部css文件url，需要https
});
});页面效果如下：
就会弹出一个二维码。。。我很无语，我都打马赛克了，二维码照片还是不能传，傻狗
实现微信扫码登录
微信端扫描二维码，点击允许，就会调用redirect_uri接口，并且会返回code临时票据
1、把微信用户信息保存到数据库
这里主要指微信用户的昵称和openid，每一个微信用户openid唯一
整体思路：
拿到code临时票据后
1.继续向微信单请求数据 access_token 和 openid
2.在用access_token 和 openid 继续向微信端请求，获取微信用户信息（昵称+头像）
3.把微信用户封装为一个UserInfo 插入到mysql
4.重定向到前端页面，这时候要是携带的openid有值就是未绑定手机号，如果openid是空字符串那么就是已经绑定过手机号
/**
* 微信扫码登录保存用户信息到mysql数据库
*/
@GetMapping("callback")
public String callback(String code) {
//得到授权临时票据code
System.out.println("code = " + code);
//1.使用code和appid以及appscrect继续向微信单请求数据 access_token 和 openid
//https://api.weixin.qq.com/sns/oauth2/access_token?appid=APPID&secret=SECRET&code=CODE&grant_type=authorization_code
StringBuffer baseAccessTokenUrl = new StringBuffer()
.append("https://api.weixin.qq.com/sns/oauth2/access_token")
.append("?appid=%s")
.append("&secret=%s")
.append("&code=%s")
.append("&grant_type=authorization_code");
String accessTokenUrl = String.format(baseAccessTokenUrl.toString(),
ConstantPropertiesUtil.WX_OPEN_APP_ID,
ConstantPropertiesUtil.WX_OPEN_APP_SECRET,
code);
try {
//使用httpclient请求这个地址
String accesstokenInfo = HttpClientUtils.get(accessTokenUrl);
//从返回字符串获取两个值 openid 和 access_token
JSONObject jsonObject = JSONObject.parseObject(accesstokenInfo);
String access_token = jsonObject.getString("access_token");
String openid = jsonObject.getString("openid");
//根据openid判断数据库是否存在微信的扫描人信息
UserInfo userInfo = userInfoService.selectWxInfoOpenId(openid);
if (userInfo == null) { //数据库不存在微信信息
//2.在用access_token 和 openid 继续向微信端请求，获取微信用户信息（昵称+头像）
String baseUserInfoUrl = "https://api.weixin.qq.com/sns/userinfo" +
"?access_token=%s" +
"&openid=%s";
String userInfoUrl = String.format(baseUserInfoUrl, access_token, openid);
String resultInfo = HttpClientUtils.get(userInfoUrl);
System.out.println("resultInfo:" + resultInfo);
JSONObject resultUserInfoJson = JSONObject.parseObject(resultInfo);
//解析用户信息
//用户昵称
String nickname = resultUserInfoJson.getString("nickname");
//用户头像
String headimgurl = resultUserInfoJson.getString("headimgurl");
//3.把微信用户封装为一个UserInfo 插入到mysql
userInfo = new UserInfo();
userInfo.setNickName(nickname);
userInfo.setOpenid(openid);
userInfo.setStatus(1);
userInfoService.save(userInfo);
}
//返回name和token字符串
Map<String,String> map = new HashMap<>();
String name = userInfo.getName();
if(StringUtils.isEmpty(name)) {
name = userInfo.getNickName();
}
if(StringUtils.isEmpty(name)) {
name = userInfo.getPhone();
}
map.put("name", name);
//使用jwt生成token字符串
String token = JwtHelper.createToken(userInfo.getId(), name);
map.put("token", token);
//判断userInfo是否有手机号，如果手机号为空，返回openid
//如果手机号不为空，返回openid值是空字符串
//前端判断：如果openid不为空，绑定手机号，如果openid为空，不需要绑定手机号
if(StringUtils.isEmpty(userInfo.getPhone())) {
map.put("openid", userInfo.getOpenid());
} else {
map.put("openid", "");
}
//跳转到前端页面 pages/weixin/callback.vue
return "redirect:http://localhost:3000/weixin/callback?token="
+map.get("token")+ "&openid="
+map.get("openid")+"&name="
+URLEncoder.encode(map.get("name"),"utf-8");
} catch (Exception e) {
e.printStackTrace();
return null;
}
}如果是第一次登录，那么会让你绑定手机号，扫完码会跳转如下。如果不是第一次登录则会把token和name共享到session登录成功。
然后点击获取验证码，之后再点击“马上登录”
2、修改登录方法绑定手机号操作
这个接口就会把微信号和手机号绑定起来
@Override
public Map<String, Object> login(LoginVo loginVo) {
//1.校验手机号和验证码不能为空
String phone = loginVo.getPhone();
String code = loginVo.getCode();
//校验参数
if (StringUtils.isEmpty(phone) ||
StringUtils.isEmpty(code)) {
throw new YyghException("数据为空", 20001);
}
//2.从redis中获取验证码，校验验证码
String mobileCode = redisTemplate.opsForValue().get(phone);
if (!code.equals(mobileCode)) {
throw new YyghException("验证码失败", 20001);
}
//判断openid值是否为空，如果为空手机验证码登录，如果不为空微信绑定手机号
String openid = loginVo.getOpenid();
if (StringUtils.isEmpty(openid)) { //不需要绑定，做手机验证码登录
//3.用手机号去查询这个用户
QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("phone", phone);
UserInfo userInfo = baseMapper.selectOne(queryWrapper);
//4.判断是注册还是登录
if (userInfo == null) {
//注册
userInfo = new UserInfo();
userInfo.setPhone(loginVo.getPhone());
userInfo.setName("");//用户真实姓名
userInfo.setStatus(1);//这行很有必要，只有主键才自动回填
this.save(userInfo);
}
//5.校验是否被禁用
if (userInfo.getStatus() == 0) {
throw new YyghException("用户已经禁用", 20001);
}
//6.给前端返回一个map，包含name和token令牌
return get(userInfo);
} else { //绑定手机号
//1 根据手机号查询，表是否存在相同手机号数据
QueryWrapper<UserInfo> wrapperPhone = new QueryWrapper<>();
wrapperPhone.eq("phone", phone);
UserInfo userInfoPhone = baseMapper.selectOne(wrapperPhone);
//判断
if (userInfoPhone == null) { //表不存在相同绑定手机
//第一次使用该手机号,做一个更新操作
UserInfo userInfoWx = this.selectWxInfoOpenId(openid);
if(userInfoWx == null) {
throw new YyghException("微信信息不存在",20001);
}
userInfoWx.setPhone(phone);
baseMapper.updateById(userInfoWx);
Map<String, Object> map = get(userInfoWx);
return map;
}else{
//手机号已经注册过，进行删除和更新操作
//1.根据openid获取微信数据
UserInfo userInfoWx = this.selectWxInfoOpenId(openid);
//2.设置要保存的那条记录
userInfoWx.setPhone(phone);
//有可能做过认证，再设置用户真实姓名...
userInfoWx.setName(userInfoPhone.getName());
userInfoWx.setCertificatesType(userInfoPhone.getCertificatesType());
userInfoWx.setCertificatesNo(userInfoPhone.getCertificatesNo());
userInfoWx.setCertificatesUrl(userInfoPhone.getCertificatesUrl());
//3.删除通过手机号验证码注册的那条记录
baseMapper.delete(new QueryWrapper<UserInfo>().eq("phone",phone));
//4.更新通过微信扫码注册的那一条记录
baseMapper.updateById(userInfoWx);
Map<String, Object> map = get(userInfoWx);
return map;
}
}
}阿里云存储图片
1、oss图片上传准备工作
1、开通oss对象服务
申请阿里云账号、实名认证、开通“对象存储OSS”服务、进入管理控制台
2、创建bucket
bucket相当于数据库，不同类型文件放在不同的bucket
用户认证需要上传证件图片、首页轮播也需要上传图片，因此我们要做文件服务，阿里云oss是一个很好的分布式文件服务系统，所以我们只需要集成阿里云oss即可
我们选择简单上传中的-上传文件流
1、引入阿里云oss相关依赖
<dependencies>
<!-- 阿里云oss依赖 -->
<dependency>
<groupId>com.aliyun.oss</groupId>
<artifactId>aliyun-sdk-oss</artifactId>
</dependency>
<!-- 日期工具栏依赖 -->
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
</dependency>
</dependencies>2、配置application.properties
#服务端口
server.port=8205
#服务名
spring.application.name=service-oss
#环境设置：dev、test、prod
spring.profiles.active=dev
spring.servlet.multipart.max-file-size=1024MB
spring.servlet.multipart.max-request-size=1024MB
#阿里云 OSS
#不同的服务器，地址不同
aliyun.oss.file.endpoint=oss-cn-beijing.aliyuncs.com
aliyun.oss.file.keyid=your accessKeyId
aliyun.oss.file.keysecret=your accessKeySecret
#bucket可以在控制台创建，也可以使用java代码创建
aliyun.oss.file.bucketname=yygh9992、实现文件上传
1、创建常量读取工具类：ConstantOssPropertiesUtils.java
使用@Value读取application.properties里的配置内容
用spring的 InitializingBean 的 afterPropertiesSet 来初始化配置信息，这个方法将在所有的属性被初始化后调用。
/**
* 常量类，读取配置文件application.properties中的配置
*/
@Component
//@PropertySource("classpath:application.properties")
public class ConstantOssPropertiesUtils implements InitializingBean {
@Value("${aliyun.oss.file.endpoint}")
private String endpoint;
@Value("${aliyun.oss.file.keyid}")
private String keyId;
@Value("${aliyun.oss.file.keysecret}")
private String keySecret;
@Value("${aliyun.oss.file.bucketname}")
private String bucketName;
public static String END_POINT;
public static String ACCESS_KEY_ID;
public static String ACCESS_KEY_SECRET;
public static String BUCKET_NAME;
@Override
public void afterPropertiesSet() throws Exception {
END_POINT = endpoint;
ACCESS_KEY_ID = keyId;
ACCESS_KEY_SECRET = keySecret;
BUCKET_NAME = bucketName;
}
}2、核心代码
conraoller层就不写了，只看service的核心代码吧
@Service
public class FileServiceImpl implements FileService {
@Override
public String upload(MultipartFile file) {
String endpoint = ConstantOssPropertiesUtils.END_POINT;
String accessKeyId = ConstantOssPropertiesUtils.ACCESS_KEY_ID;
String accessKeySecret = ConstantOssPropertiesUtils.ACCESS_KEY_SECRET;
String bucketName = ConstantOssPropertiesUtils.BUCKET_NAME;
try {
// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
// 上传文件流。
InputStream inputStream = file.getInputStream();
String fileName = file.getOriginalFilename();
//生成随机唯一值，使用uuid，添加到文件名称里面
String uuid = UUID.randomUUID().toString().replaceAll("-","");
fileName = uuid+fileName;
//按照当前日期，创建文件夹，上传到创建文件夹里面
// 2021/02/02/01.jpg
String timeUrl = new DateTime().toString("yyyy/MM/dd");
fileName = timeUrl+"/"+fileName;
//调用方法实现上传
ossClient.putObject(bucketName, fileName, inputStream);
// 关闭OSSClient。
ossClient.shutdown();
//上传之后文件路径
// https://yygh-atguigu.oss-cn-beijing.aliyuncs.com/01.jpg
String url = "https://"+bucketName+"."+endpoint+"/"+fileName;
//返回
return url;
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
}3、在页面中用户认证后，在我们创建的bucket文件管理下，就能找到上传的图片了
1005
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
