We Keep Coding

How should my proxy intercept packets

I have two web servers A and C. Because of rules, policies etc A cannot communicate directly with C' (Crequires requests to have special security headers andA` does not support this)
I want to create a "proxy" called B in Java, to facilitate communication between A and B but I having trouble with it conceptually.
When you create a proxy, don't you have to change the hard coded URLs on all your services to now travel through the proxy? And then I suppose you must pass your destination as a query parameter somehow, for example
http://proxy.com/?destination=mydestination.com
Is this how a proxy would work?
(I have found a few similar questions but they do not resolve the fundamental question I am having i.e. How packets reaches Destination throgh proxy servers?)

Don't write your own proxy from scratch that will be a redo, there are a plenty of proxy implementations out there
Spring framework
Spring Boot implementation for (Netflex/Zuul) https://github.com/Netflix/zuul / https://spring.io/guides/gs/routing-and-filtering/
Standard Servlet
https://github.com/mitre/HTTP-Proxy-Servlet
in case if you are intrested in how you can build up your own proxy , here is a simple example using spring framework (Servlet implementation is not that far from spring implementation)
#RestController
public class ProxyController {
/**
* request handler for all the requests on the registered context intended to be proxied
*
* #param request
* #return
*/
#RequestMapping("/**")
public String defaultGateway(HttpServletRequest request) {
// edit the original request headers,body etc
String originalPath = request.getRequestURI();
// then fire another HTTP request using the same URI
return "ProxiedResult"; // return back the result you get from
}
}
the example above is a start point on how to implements HTTP proxy or how it is working there are many things to cover which is droped off like security for instance

What is the essence of "exposing" an API especially in Google Cloud Endpoint?

I am totally new to the whole Google Cloud Endpoint/Google App Engine world. If you have gone through the Hello World example that Google provides(and you probably have), you might remember that there are 2 classes that are auto-generated for you: MyBean and MyEndpoint.
These are something like this:
/**
* The object model for the data we are sending through endpoints
*/
public class MyBean {
private String myData;
public String getData() {
return myData;
}
public void setData(String data) {
myData = data;
}
}
And,
/**
* An endpoint class we are exposing
*/
#Api(
name = "myApi",
version = "v1",
namespace = #ApiNamespace(
ownerDomain = "backend.myapplication.DJ.example.com",
ownerName = "backend.myapplication.DJ.example.com",
packagePath = ""
)
)
public class MyEndpoint {
/**
* A simple endpoint method that takes a name and says Hi back
*/
#ApiMethod(name = "sayHi")
public MyBean sayHi(#Named("name") String name) {
MyBean response = new MyBean();
response.setData("Hi, " + name);
return response;
}
}
Now, I examined the code in index.html(which gets opened on deploying the backend). I found the following call in the javascript:
gapi.client.myApi.sayHi({'name': name}).execute(
Now, I can see that myApi is the name through annotation and sayHi() is the corresponding method, What I don't understand is the concept of exposing an API and annotation is aiding in that. There isn't any information about exposing APIs.
Could anyone help me understand this?

I think your question can be divided in 3 parts:
1/ What is exposing an API?
Basically, you are offering an access to your business logic through an Interface (the API), with full control on what you want to show or not. This Stack Exchange answer is a great explanation: https://softwareengineering.stackexchange.com/questions/203844/what-does-it-mean-to-expose-something
2/ What are these annotations in the auto-generated endpoints class?
If I can summarize it like that, Google endpoint is a "framework" which generates "default" APIs based on your java beans. By default you get CRUD operations in the API, but you can modify and/or enrich the endpoint to offer more complex business logic. The Endpoints classes that are generated include specific annotations that are used by the framework (in particular while generating a corresponding servlet) and define the URI you will call to interact with the methods of the APIs. See https://cloud.google.com/appengine/docs/java/endpoints/
3/ What is this gapi.client call?
gapi stands for Google API Client Library. It is the library that is offered by Google to interact with Endpoints from a web browser. See https://developers.google.com/api-client-library/javascript/
You could use other methods to call the Endpoint APIs, like jquery Ajax methods (http://api.jquery.com/jquery.ajax/), since Endpoints follow the REST architectural style. Note that you can call your endpoints from other "clients" than a web browser, e.g. an Android or iOS App. In these cases, you would not use the Google API Client Library but some other libraries.
I hope this clarifies a bit. Do not hesitate to ask for more details.

How can i create a java web service that supports multiple client requests using only java SE?

I have the task of creating a web service that takes requests from multiple clients. I am new to web services so i used this tutorial:
http://www.java-forums.org/blogs/web-service/1145-how-create-java-web-service.html
This is exactly what i am looking for. A web service with no java ee.
It is preferable that is stick with java se, it's a policy that is prefered to be kept.
Now i would like to go one step further and implement the service so that it processes requests from multiple clients that operate on a shared resource.
Ideally i would like something like this:
Client client = new Client();
client.processRequest(string);
And the web service will process the requests in the order they arrive. The requests will come in as an request is processed so it will be kept in a stack.
The problem is i just on't know how to send the response back to the specific client. The response will be a string. The only thing i came up with, at least in principle, is to send a object that remembers where it came from but that just seems the web services job.
I have searched the internet but did not find a solution.
If possible using only SE please help.
If you think it is not possible without EE you can say so, but i would very much like an answer using only SE

I think what you are trying to implement is an Asynchronous Webservice. The following link tells you how to implement it in Java SE.
http://java.dzone.com/articles/asynchronous-java-se-web

You can do this using the Endpoint.publish methods in Java SE. First, you create a simple "endpoint interface":
package com.example;
import javax.jws.WebService;
#WebService
public interface ExampleService {
String getDateTime();
}
Then you specify that interface in an implementation class. As you can see, both classes must be annotated with #WebService.
package com.example;
import java.io.IOException;
import java.net.URL;
import javax.jws.WebService;
import javax.xml.ws.Endpoint;
import javax.xml.ws.Service;
import javax.xml.namespace.QName;
#WebService(endpointInterface = "com.example.ExampleService",
serviceName = "ExampleService",
portName = "timeService",
targetNamespace = "http://example.com/time")
public class ExampleServiceImpl
implements ExampleService {
public String getDateTime() {
return String.format("%tc", System.currentTimeMillis());
}
public static void main(String[] args)
throws IOException {
// Create server
Endpoint endpoint =
Endpoint.publish("http://localhost:8080/example",
new ExampleServiceImpl());
URL wsdl = new URL("http://localhost:8080/example?wsdl");
// Create client
Service service = Service.create(wsdl,
new QName("http://example.com/time", "ExampleService"));
ExampleService e = service.getPort(ExampleService.class);
// Test it out
System.out.println(e.getDateTime());
endpoint.stop();
}
}
By default, JAX-WS will treat all public methods of an endpoint interface as web methods (since that is commonly what developers will want). You can have more control by placing the #WebMethod annotation on only the methods you want exposed as web services.
See the JAX-WS specification for all the details.

How to have the ability of invoking methods by http?

I've written an an API giving some methods like
runApp();
stopApp();
doSomethingElse();
currently I have a jar file with which I run these methods.
I want to be able to invoke these method by http.
For example, going to : http://localhost:8080/something/runApp
will invoke runApp() method.
I've heard that this should be done with webservices, and particularly REST API.
Is webservices the only way to achieve this?
And if so, can someone summarize the simplest ways to implement this ability, or point me to an existent summary?
Thanks.

Here's a RESTful API example based on your pseudocode, with JAX-RS:
#Path("/something")
public class MyApp {
#GET
#Path("/runApp")
public Response runApp() {
return Response.ok("Running app").build();
}
#GET
#Path("/stopApp")
public Response stopApp() {
return Response.ok("Stopping app").build();
}
#GET
#Path("/doSomethingElse") {
return Response.ok("Doing something else").build();
}
}
Which when built and deployed into any JEE5 or JEE6 web capable container will allow you to access services those services at:
http://localhost:8080/something/runApp
http://localhost:8080/something/stopApp
http://localhost:8080/something/doSomethingElse
Assuming your server is running on localhost:8080, of course. Having said that, nothing in this example is really RESTful, and would be better implemented using JAX-WS.

You've pretty much described exactly what a web service is. Code gets run when you hit a particular URL with a particular type of request.
As to how to build a web service in Java, there's a huge amount of documentation out there on the web (and SO) on that. You should not have any trouble finding useful articles.

How Would I Do This in Java? (A blog with some java callbacks)

I want to build a website that is basically a blog with a little bit of custom java code to be run via ajax calls on the server.
My initial thoughts were to build the blog in wordpress or drupal or something similar, then run a very simple java webapp to receive the ajax requests. However, having no experience with Java webapps, I am not sure of a framework made for such simple tasks. Nor have I ever used wordpress/drupal/etc to know how easy it would be to integrate these java ajax calls.
Then I thought, perhaps I should just run some Java CMS instead of drupal, wordpress, etc. This should allow me to easily integrate my ajax hooks. But again, I have no experience with any Java CMS's to know which would work well.
Can someone with some Java webapp experience give their recommendation?

Second time in two posts I have made the same recommendation (!) but maybe look at the free Community edition of Liferay portal server? It runs on Java (easy on tomcat+mysql) and has blogs and CMS and other features included. There is also the option of modifying the source code (subject to the license) to add your custom behaviour.

What exactly are you looking to do in Java that you couldn't accomplish in PHP if you were to use Wordpress or Drupal?
Wordpress is rather easy to setup. If you have any web app experience at all and minor knowledge of PHP then you shouldn't have any problems.
Spring MVC is a fairly straightforward Java web app framework. You can run it on Google App Engine with relative ease and there's a lot of documentation / support online.
One thing to consider is that your AJAX calls will need to be made to the same domain that your CMS is on. If you're creating two separate web apps then they need to appear to be on the same domain.
It's a bit difficult to give any detailed advice not knowing what your particular requirements are but I hope this helped a little.

I think you shouldn't use any framework. Just create a servlet. Because even if you use a framework, you still have to understand what a servlet is. These code are from oracle's site, modify doGet to do your processing. Or you could change it to doPost.
import java.io.*;
// Packages for Servlets
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet {
/**
* Initializes the servlet. The method is called once, automatically, by the
* Java Web Server when it loads the servlet. The init() method should save
* ServletConfig object so that it can be returned by the getServletConfig()
* method.
*/
public void init(ServletConfig config) throws ServletException {
super.init(config);
}
/**
* Method to process HTTP GET requests. In this method a Simple HTML page
* displaying "Hello Oracle World" is built and presented to user.
* The parameters of doGet() method is
* 1) HttpServletRequest object, which encapsulates the data from the client
* 2) HttpServletResponse object, which encapsulates the response to the client
**/
public void doGet(HttpServletRequest p_req, HttpServletResponse p_res)
throws ServletException, IOException {
// Sets the content type of the response
p_res.setContentType("text/html");
// Create a ServletOutputStream to write the output
ServletOutputStream l_out = p_res.getOutputStream();
// Use ServletOutputStream to print the Hello Oracle World String in
// the HTML page
l_out.println("<HTML><HEAD><TITLE>Hello Oracle World</TITLE></HEAD>");
l_out.println("<BODY BGCOLOR =\"lightgrey\"><CENTER><BR><BR>");
l_out.println("<TABLE BORDER=4 BGCOLOR =\"blue\">");
l_out.println("<TR><TD align =\"center\" valign=\"center\" >");
l_out.println("<FONT face=\"Arial,helvetica\" color =red size=5>");
l_out.println(" Hello Oracle World </FONT></TD></TR></TABLE>");
l_out.println("</BODY></HTML>");
l_out.close(); // Close the ServletOutputStream
}
/**
* Override the getServletInfo() method which is supposed to return information
* about the Servlet, e.g. the servlet name, version, author and copyright
* notice. This is not required for the function of the HelloWorld servlet but
* can provide valuable information to the user of a servlet who sees the
* returned text in the administration tool of the Web Server.
**/
public String getServletInfo() {
return "Hello World servlet 1.0 by Reghu";
}
public void destroy() {
super.destroy();
}
}