精华内容
下载资源
问答
  • 用loadjava 把写好的java程序加载到oracle,执行了,没报错,但是请求不到web服务器,在eclipse里面都能请求到,求大神指点一下[img=https://img-bbs.csdn.net/upload/201410/25/1414220381_911769.png][/img]
  • 要开发五个接口供安卓贪吃蛇游戏上传和获取玩家排行榜数据,求大神指导。之前没有写过接口。
  • 言归正传,怎么通过java调用别人写的接口了?我们在网上看到大部分都是有点麻烦的,其实我们可以通过RestTemplate 进行开发,常用的http基本请求方式都有 Get,Post ,Put ,Delete,等等 我这里的是post请求,参数中...

       最近公司派我出差与乙方公司对接接口,开发了将近大半年的App,突然有冲突,所以整合一下,此处省略十万八千字......

       言归正传,怎么通过java调用别人写的接口了?我们在网上看到大部分都是有点麻烦的,其实我们可以通过  RestTemplate

    进行开发,常用的http基本请求方式都有  Get,Post ,Put ,Delete,等等

        我这里的是post请求,参数中含有 list 的,map传参

        首先我们创建一个配置类 

    package com.japhet.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    @Configuration(value = "config2")
    public class Config {
        @Bean
        public RestTemplate restTemplate(){
            return new RestTemplate();
        }
    }
    
    
        @Resource
        private RestTemplate restTemplate;
    
    //  核心
        public  String doPost(String url,Map<String, Object> params) throws Exception {
            JSONObject jsonObject =  restTemplate.postForObject(url,params,JSONObject.class);               
            return jsonObject.toString();
        }
    
    //调用
        public static void main(String[] args) {
    
            if(true){//自己业务
                for(int i=0;i<10;i++){
                    stringList.add("参数"+i);
                }
            }else{
                stringList.add("参数1");
            }
            JSONArray jsonArray = JSONArray.fromArray(new ArrayList[]{stringList});
            String listJson = jsonArray.toString();
            map.put("xxx", "参数1");
            map.put("xxx", listJson);
            map.put("xxx",  "参数1");
            map.put("xxx", "参数1");
            map.put("xxx", "参数1");
    
            try{
                String result = doPost("接口路径",map);
            }catch (Exception e){
                e.printStackTrace();
            }
        }

    get 请求 后续更新.....

    展开全文
  • http://116.90.87.221/qxt_jtd/sendSms?mobile=1380009999&...我现在需要将一个Java程序封装成上面一个请求,只需要调用请求同时传递参数就可以实现java程序的功能,求大神指点下!!java程序已经写好了。
  • Rest接口格式:每一个请求通常由三部分组成:请求行、请求报头、请求正文(可选)。 请求样例: ... 但是怎么java代码里写请求行:Post <basic_uri>/services/ita/login HTTP/1.1的信息呢?
  • server return http response code :405 for url 这个怎么解决,调用接口规定以put方式
  • (具体怎么做的应该就是个网关,然后将http请求转为dubbo请求,通过泛化调用去进行调用。代码看不到。)现在为了方便测试,我需要将配置的接口,通过http请求去请求对应的链接。 分析 项目是个简单的spring项目就行...

    场景

    现在想要做这么一个事情,公司的dubbo服务都是内网的,但是提供了一个对外的出口,通过链接就能请求到对应的dubbo服务。(具体怎么做的应该就是个网关,然后将http请求转为dubbo请求,通过泛化调用去进行调用。代码看不到。)现在为了方便测试,我需要将配置的接口,通过http请求去请求对应的链接。

    分析

    项目的思想其实跟mybatis-spring整合包的思想差不多,都是生成代理去执行接口方法。
    https://yidajava.blog.csdn.net/article/details/108120233
    项目是个简单的spring项目就行了,然后项目引入项目的api,然后通过配置对应的服务名称,通过spring生成代理,注入spring容器,然后执行方法就是根据对应的域名+接口全路径+方法名去进行请求,参数是json。为了方便项目使用了hutool工具类,直接使用fastjson去进行序列化。

    操作

    首先创建工厂bean,就是用来返回代理的FactoryBean

    
    import org.springframework.beans.factory.FactoryBean;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import java.lang.reflect.Proxy;
    
    /**
     * @Title:相对于BeanFactory这个大工厂,这是一个小工厂,专门用于创建某种类型的bean(默认创建的是单例bean)
     * @Description 创建代理对象
     * @Version
     */
    public class HttpProxyFactoryBean<T> implements FactoryBean<T> {
    
        /**
         *【注意】
         * 这里之所以可以进行自动装配,是因为当前的这个HttpProxyFactoryBean是会被注册到Spring中的
         * 只不过它的注册方式 跟一般的不一样(一般会在类上,加一个如@Component、@Service这样的注解 )
         * 它是通过注册BeanDefinition的方式注册的,可能会注册多个,而其中的每一个HttpProxyFactoryBean实例都会被自动装配同一个HttpProxyInvocationHandler实例
         *
         * 也有等价的做法是:
         * 利用ApplicationContextAware接口的setApplicationContext获取到applicationContext,
         * 然后把applicationContext 作为属性设置到当前类中
         *  再利用applicationContext的getBean方法来获取InvocationHandler的实例
         */
        @Autowired
        private HttpProxyInvocationHandler httpProxyInvocationHandler;
    
        private Class<T> rpcInterface;
    
        public HttpProxyFactoryBean(Class<T> rpcInterface){
            this.rpcInterface = rpcInterface;
        }
    
    
        @Override
        public T getObject() throws Exception {
            //这里应该放ComputerService接口
            return (T)Proxy.newProxyInstance(rpcInterface.getClassLoader(),new Class[]{rpcInterface} ,httpProxyInvocationHandler);
        }
    
        @Override
        public Class<?> getObjectType() {
            return rpcInterface;
        }
    
    }
    

    每一个动态代理类都必须要实现InvocationHandler这个接口

    每一个动态代理类都必须要实现InvocationHandler这个接口,并且每个代理类的实例都关联到了一个handler,当我们通过代理对象调用一个方法的时候,这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

    我们可以直接将实现InvocationHandler的实现类注入spring容器中,然后每一个接口走同一个innvoke方法,当然也可以每一个都new一个,然后可以在构造方法中塞入特定的一些参数。我这边因为对应的每一个代理没啥特殊的就走同一个了:
    定义一些参数,请求的urlproxy.serverUrl,和请求添加的项目,proxy.project

    
    import cn.hutool.http.HttpRequest;
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @Description 把服务方法的调用转换为对远程服务的http请求
     * @Version
     */
    @Component
    public class HttpProxyInvocationHandler implements InvocationHandler {
    
        @Value("${proxy.serverUrl}")
        private String serverUrl;
    
        @Value("${proxy.project}")
        private String serverProject;
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Class<?> declaringClass = method.getDeclaringClass();
            if (Object.class.equals(declaringClass)) {
                return method.invoke(this, args);
            }
    
            String methodName = method.getName();
            String name = method.getDeclaringClass().getName();
    
            //拼接请求地址
            String url = serverUrl + name + "/" + methodName;
    //        String url = "http://test:8080/soa/com.rdd.TestService/createActivity";
            HashMap<String, String> paramMap = new HashMap<>();
        
    //        String result = HttpRequest.post(url).headerMap(paramMap, true).body("[" + JSONObject.toJSONString(args) + "]").execute().body();
            String result = HttpRequest.post(url).headerMap(paramMap, true).body(JSONObject.toJSONString(args)).execute().body();
    
            System.out.println(">>>" + url + "的响应结果为:" + result);
    
            //将响应结果转换为接口方法的返回值类型
            Class<?> returnType = method.getReturnType();
            if (returnType.isPrimitive() || String.class.isAssignableFrom(returnType)) {
                if (returnType == int.class || returnType == Integer.class) {
                    return Integer.valueOf(result);
                } else if (returnType == long.class || returnType == Long.class) {
                    return Long.valueOf(result);
                }
                return result;
            } else if (Collection.class.isAssignableFrom(returnType)) {
                return JSONArray.parseArray(result, Object.class);
            } else if (Map.class.isAssignableFrom(returnType)) {
                return JSON.parseObject(result, Map.class);
            } else {
                return JSONObject.parseObject(result, returnType);
            }
        }
    }
    

    最后后将对应的工厂bean封装成bean定义,注入到spring容器中

    我们的接口一般都是jar形式的,我就简单的写在一个proxy.txt文件中,然后去读取对应的接口全路径,注入到spring容器中,当然也可以通过扫描某个包,自定义注解等等方式实现。

    import cn.hutool.core.io.file.FileReader;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.beans.factory.support.*;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    
    /**
     * @Title:bean工厂的后置处理器,用于动态注册bean
     * @Date 2021/3/23 10:13
     * @Description
     * @Version
     */
    @Component
    @PropertySource("classpath:application.properties")
    public class HttpProxyRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    
        /**
         * 该方法用来注册更多的bean到spring容器中
         *
         * @param beanDefinitionRegistry
         * @throws BeansException
         */
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
            //默认UTF-8编码,可以在构造中传入第二个参数做为编码
            FileReader fileReader = new FileReader("proxy.txt");
            List<String> classStrList = fileReader.readLines();
            Set<Class<?>> proxyClazzSet = new HashSet<>();
            for (String s : classStrList) {
                if (StringUtils.isBlank(s)) {
                    continue;
                }
                try {
                    Class<?> aClass = Class.forName(s);
                    proxyClazzSet.add(aClass);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
    
            for (Class<?> targetClazz : proxyClazzSet) {
                BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(targetClazz);
                GenericBeanDefinition definition = (GenericBeanDefinition) beanDefinitionBuilder.getRawBeanDefinition();
                //设置构造方法的参数  对于Class<?>,既可以设置为Class,也可以传Class的完全类名
                //definition.getConstructorArgumentValues().addGenericArgumentValue(targetClazz);
                definition.getConstructorArgumentValues().addGenericArgumentValue(targetClazz.getName());
    
                //Bean的类型,指定为某个代理接口的类型
                definition.setBeanClass(HttpProxyFactoryBean.class);
                //表示 根据代理接口的类型来自动装配
                definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);
                beanDefinitionRegistry.registerBeanDefinition(targetClazz.getName(),definition);
            }
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
    
        }
    }
    
    展开全文
  • 做项目的时候碰到一个问题,怎么才能在代码里通过http发起一个请求调用代码里另外一个接口的url, 都是在同一个项目里,并且只能通过url来请求 有没有大佬知道方法 求解答
  • HttpServletRequest请求是获取请求行、请求头和请求体;可以通过这个方法设置防盗链,获取地址。牢记解决乱码的方式。  怎么选择是重定向还是转发呢?通常情况下转发更快,而且能保持request内的对象,所以他是第...

       HttpServletRequest请求是获取请求行、请求头和请求体;可以通过这个方法设置防盗链,获取地址。牢记解决乱码的方式。

      怎么选择是重定向还是转发呢?通常情况下转发更快,而且能保持request内的对象,所以他是第一选择。但是由于在转发之后,浏览器中URL仍然指向开始页面,此时如果重载当前页面,开始页面将会被重新调用。如果你不想看到这样的情况,则选择转发。详见https://www.cnblogs.com/wenanbang/p/4142415.html

    其实也可以单纯的认为是若是带数据的话就请求转发了,若改地址的话就重定向了。

    一、HttpServletRequest:

      概述和运行流程详见HttpServletResponse!

    二、获取HTTP请求:

     三、获取请求行:

    1、获得客户端的请求方式:

    getMethod()     获得String类型;

    2、获得请求的资源:

    getContextPath() 获得String类型的 web应用的名称(项目名)

    getQueryString() 获得 get提交url 地址后的参数字符串;

     getRequestURI() 获取URI地址String类型

     getRequestURL() 获取URL地址StringBuffer类型

    request.getRemoteAddr() 获得访问的客户端IP地址

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 获取请求方式
            String method = request.getMethod();
            System.out.println("请求方式为:" + method);
            // 获取请求URI
            String URI = request.getRequestURI();
            System.out.println("URI为" + URI);
            // 获取请求URL
            StringBuffer URL = request.getRequestURL();
            System.out.println("URL为:" + URL);
            // URI为/WEB/LineServlet
            // URL为:http://localhost:8080/WEB/LineServlet
            // 获取WEB项目名称
            String name = request.getContextPath();
            System.out.println("WEB项目名称为:" + name);
            // 获取get请求后url后的字符串
            String query = request.getQueryString();
            System.out.println("get请求的参数为:" + query);
            // 获取客户端的ip地址
            String ip = request.getRemoteAddr();
            System.out.println("ip地址为:" + ip);
        }

    四、获取请求头:

     getHeader(String name) 

    referer 头的作用:获取该访问的来源,做防盗链

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            // 获取refere头
            String refere = request.getHeader("Referer");
            String content = null;
            if(refere.startsWith("http://localhost:8080")){
                content="真的离婚了!";        
            }else{
                content="你是小偷!";
            }
            //解决乱码
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write(content);        
        }
    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
        <a href="/WEB/RefereServlet">宋仲基和宋慧乔分手了</a>
    </body>
    </html>

    五、获得请求体:

    1、解决post提交方式的乱码:request.setCharacterEncoding("UTF-8");

    2、解决get提交的方式的乱码:

                parameter = new String(parameter.getbytes("iso8859-1"),"utf-8");

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            //解决中文乱码问题(post请求)
    //        request.setCharacterEncoding("UTF-8");
            //获取请求参数
            //1.单个值的参数
            String name=request.getParameter("username");
            //get解决乱码:得先将获取到的信息用原来的编码表进行解码,然后再用后来的编码表进行编码
            name=new String(name.getBytes("ISO-8859-1"),"UTF=8");
            String sex=request.getParameter("sex");
            System.out.println(name+" ......"+sex);
            //2.获取多个值的
            String[] hobbys=request.getParameterValues("hobby");
            //遍历
            for(String s:hobbys){
                System.out.println(s);
            }
            //3.获取所有的请求参数MAP
            Map<String,String[]> map=request.getParameterMap();
            //遍历
            Set<String> set=map.keySet();
            for(String str:set){
                String [] value=map.get(str);
                for(String v:value){
                    System.out.println(str+"..."+v);
                }
            }        

     

    六、request的其他功能:

    1、request 也是个域对象,也是具有以下功能:

      setAttribute(String name, Object o)

      getAttribute(String name)

      removeAttribute(String name)

    2、request完成请求转发:

      获得请求转发器----path是转发的地址

    RequestDispatcher getRequestDispatcher(String path)

      通过转发器对象转发

    requestDispathcher.forward(ServletRequest request, ServletResponse response)

    七、ServletContext域与Request域的生命周期比较

    1、ServletContext

           创建:服务器启动

           销毁:服务器关闭

           域的作用范围:整个web应用

    2、request

          创建:访问时创建request

          销毁:响应结束request销毁

          域的作用范围:一次请求中

    八、转发和重定向的区别:

    1、重定向两次请求,转发一次请求

    2、重定向地址栏的地址变化,转发地址不变

    3、重新定向可以访问外部网站 转发只能访问内部资源

    4、转发的性能要优于重定向

    (需要带数据的时候用请求转发,由第一个Servlet01带数据到Servlet02需要地址转变的用重定向)

    public class Servlet01 extends HttpServlet {
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            //向request域中存值
            request.setAttribute("name", "张三" );
            //请求转发
            request.getRequestDispatcher("/Servlet02").forward(request, response);
        
            
        }
    public class Servlet02 extends HttpServlet {
    
        public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            //从request 域中取值
            String name =(String)request.getAttribute("name");
            //解决中文乱码
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("hello"+name);
        }

     

    转载于:https://www.cnblogs.com/21-forever/p/11131113.html

    展开全文
  • 1.http服务器收到http请求后,会调用服务端程序来处理这个请求,这些程序,就是我们写的Java类。 2.定义servlet接口来专门处理这些请求。 3.Servlet 容器用来加载和管理业务类(实现servlet接口的类); HTTP ...

    在上一篇我们说的到,浏览器发起请求后,通过http协议,服务器会收到请求。那么服务器是怎么接收和处理请求的呢?这篇博客就来谈论一下这个问题。

    1.http服务器收到http请求后,会调用服务端程序来处理这个请求,这些程序,就是我们写的Java类。

    2.定义servlet接口来专门处理这些请求。

    3.Servlet 容器用来加载和管理业务类(实现servlet接口的类);

    HTTP 服务器不直接跟业务类打交道,而是把请求交给 Servlet 容器去处理,Servlet 容器会将请求转发到具体的 Servlet,如果这个servlet还没有创建,就加载并实例化这个 Servlet。

    然后调用这个 Servlet 的接口方法。因此 Servlet 接口其实是Servlet 容器跟具体业务之间的接口。

     

     

    下一篇我们再来具体讨论servlet是怎么处理请求的,即servlet规范

     

     

     

    展开全文
  • 最近做项目需要调用magento里面的文档,但发现都是PHP写的,自己摸索卡在了第一步身份认证上,不明白获取请求令牌url地址该怎么写。 magento官方文档地址:...
  • 我现在在写一个eclipse的插件,主要是通过java向服务器发出httppost的请求调用一些比如登陆啊等等的服务器端api。就是模拟浏览器操作 但是现在遇到了一个问题,服务器端的程序要检查浏览器是不是支持javascript...
  • java中A项目调用B项目的功能,怎么HTTP实现?现在知道B项目这一功能的请求路径和所需参数,求具体代码
  • 工作中调用https接口时不知道应该怎么绕过ssl验证,本文用RestTemplate请求实现。 首先新建工具类,上代码 import java.security.KeyManagementException; import java.security.KeyStoreException; import java....
  • * 调用Post接口 */ public static void httpURLConnectionPOST(){ try { URL url = new URL(POST_URL); HttpURLConnection connection = (HttpURLConnection) url.openConnection(); connection....
  • array是java类型的对象集合对象,就可以在调用存储过程时作为数组参数传入。 需注意的是,connection必须是Native Connection,如果connection是通过JDBC建立数据库连接并获取的,就不会有问题, 但是...
  • Java通过form-data传参调用第三方接口

    千次阅读 2020-06-03 17:18:44
    今天被PHP同事问到, 你们java中在postman...http请求中的multipart/form-data,它会将表单的数据处理为一条消息,以标签为单元,用分隔符分开。既可以上传键值对,也可以上传文件。当上传是文件时,会有Content-Typ...
  • [quote]web service的调用,我怀疑是不能以out.write(new String(request.getBytes("ISO-8859-1")));把请求内容写进去就当是post [/quote] 我觉得可能不是这个问题 因为con.setDoOutput(true); 就意味着post了
  • HTTP请求方式:GET http://ip:port/lanshuijsdService/3.0/hts/queryCyr?param_key=?&secret_key=? 1) 注意: 以JSON格式传入输入参数 1) 请求参数 参数名称 类型 必需 描述 param_key 字符串 是 输入参数值 secret...
  • C# HTTP请求之POST

    2019-07-10 17:14:14
    在做一个项目(winform)需要调用Java提供的接口,然后就直接使用HttpWebRequest、HttpWebResponse结果怎么搞都不行。。。。。 在这里记录一下:url:接口地址;postdata:参数 public string HWRPost(string url...
  • 最近需要使用java对Rest接口进行调用,也就是直接使用java直接发送Post, Get, Put, Delete等请求。 印象中可以使用Apache Common下的HttpClient来做,结果HttpClient已经独立成了HttpComponent,编码方式也有所改变...
  • 几乎从一接触java就接触了tomcat,可是这只猫到底是怎么工作的一直也没时间研究,今天开始好好研究一下,第一次写,先拿这里当个记录的地方,说的比较乱,主要是用来存点乱七八糟的东西。 先抄一段tomcat的启动定义...
  • 配合Netty实现简单的HTTP请求处理框架 其他需要使用反射执行Spring方法的业务亦可 目的 很多文章都提到了反射,但是对于方法参数处理这一块都是明确了类型,不支持按照实际参数动态转换,而本篇文章提供了一个...
  • Spring Cloud中如何优雅的使用Feign调用接口

    万次阅读 多人点赞 2017-11-30 10:37:45
    JAVA 项目中接口调用怎么做 ? Httpclient Okhttp Httpurlconnection RestTemplate 上面是最常见的几种用法,我们今天要介绍的用法比上面的更简单,方便,它就是 FeignFeign是一个声明式的REST客户端,它的目的就是...
  • 主要是由于我们项目架了KONG网关并限定了请求方式的影响,导致平常的动态客户端方式无法成功调用webservice实例,因此便花了半天多时间研究了下webservice服务这一块,并利用soap协议通过http成功调用,虽然有局限性...
  • JAVA 项目中接口调用怎么做 ? HttpClient OKhttp RestTemplate 上面是最常见的几种用法,我们基于目前主流的SpringBoot简单的介绍一下用法及对比。 基于springboot的HttpClient、OKhttp、RestTemplate对比 一、...
  • # 想实现的功能: 微服务间调用主要有springcloud和Dubbo两种,有时...我的理解,springcloud基本是http请求,写法上与本地调用不同,实现上述要求有些困难,Dubbo写法上与本地请求一样,是否可以实现?怎么实现呢?
  • 当然,如果这个请求是自己企业已知的或者是被企业已信任的,这个时候,咱们就会为了编程的方便,不需要把请求路径的根证书以及中间证书导入到JKS中了,让程序在调用HTTP协议的时候对服务器的服务器名和证书名进行...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 159
精华内容 63
关键字:

java怎么调用http请求

java 订阅