For some reason we wanted to abort a current pending merge because maybe of some conflicts. We can use the following command:
git merge --abort
Extremely Serious
For some reason we wanted to abort a current pending merge because maybe of some conflicts. We can use the following command:
git merge --abort
Source: https://github.com/flofreud/posh-gvm
Introduction
A tool for managing parallel Versions of multiple Software Development Kits on a windows based system.
Powershell Behind Proxy
Setting default Powershell TLS Protocol
Installation via Short Script
Invoke-WebRequest -Uri 'https://raw.githubusercontent.com/flofreud/posh-gvm/master/GetPoshGvm.ps1' | iex
Usage
Displaying the tool capability using the following:
gvm [help]
Useful Commands
Command | Description |
list | Lists the available, installed and default versions of the candidate. |
install | Downloads and installs a particular candidate version (i.e. will default to latest if version is not specified) |
use | Uses a particular candidate version that is not the default. |
default | Sets a default version to use of a particular candidate. |
current | Displays the current active candidates version. |
uninstall | Uninstalls a particular candidate version. |
Design patterns are fundamental concepts in software engineering that provide reusable solutions to common problems. They help in creating more maintainable and scalable software. In this article, we will explore several design patterns and provide Java examples for each pattern's practical application.
The Intercepting Filter Pattern is used when the intent is to perform pre or post-processing with the request or response of an application, typically in web applications. In Java, you can implement this pattern using servlet filters. Here's an example:
public class LoggingFilter implements Filter {
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
// Pre-processing logic
// ...
// Pass the request to the next filter or servlet in the chain
chain.doFilter(request, response);
// Post-processing logic
// ...
}
// Other methods for initialization and cleanup
}
The Front Controller Pattern is employed when the intent is to have a centralized request handling mechanism that dispatches requests to the appropriate handlers. In Java EE applications, a servlet can act as a front controller. Here's a simplified example:
public class FrontControllerServlet extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// Determine the appropriate handler for the request
// ...
// Dispatch to the appropriate handler
// ...
}
}
The Business Delegate Pattern is used when the intent is to provide a single point of entry for clients to access business services, especially when separating the presentation tier and the business tier. Here's a simple Java example:
public class BusinessDelegate {
private BusinessService businessService;
public BusinessDelegate() {
businessService = new BusinessService();
}
public void doTask() {
// Delegate the task to the business service
businessService.doTask();
}
}
The Composite Entity Pattern is often used in database applications to manage a graph of persistent objects using a primary composite entity. Here's a basic Java example:
public class CompositeEntity {
private CoarseGrainedObject cgo = new CoarseGrainedObject();
public void setData(String data1, String data2) {
cgo.setData(data1, data2);
}
public String[] getData() {
return cgo.getData();
}
}
The Service Locator Pattern is employed when the intent is to locate services using JNDI (Java Naming and Directory Interface) lookup. Here's a simplified example:
public class ServiceLocator {
public Service getService(String serviceName) {
// Perform JNDI lookup to obtain the service
// ...
// Return the service
return service;
}
}
The Session Facade Pattern can be used in Java EE applications when the intent is to encapsulate business-tier components and expose a coarse-grained service to remote clients. Here's a basic example:
public class SessionFacade {
private BusinessComponent businessComponent;
public SessionFacade() {
businessComponent = new BusinessComponent();
}
public void performBusinessOperation() {
// Encapsulate business logic and provide a coarse-grained service
businessComponent.performOperation();
}
}
The Transfer Object Pattern is used to pass data with multiple attributes in one shot from the client to the server. In Java, this pattern is typically implemented using POJOs (Plain Old Java Objects) with getter and setter methods, and the objects must be serializable. Here's a simple example:
public class TransferObject implements Serializable {
private String attribute1;
private int attribute2;
// Getter and setter methods for attributes
// ...
}
The Value List Handler Pattern is used for managing the results of search operations, especially when results can be paged and traversed iteratively. Here's a basic example:
public class ValueListHandler {
public List<ValueObject> getPage(int pageNumber) {
// Retrieve a specific page of results
// ...
}
}
The Data Access Object (DAO) Pattern is commonly used in Java EE applications to separate data persistence logic into a separate layer. Here's a simplified example:
public class UserDao {
public User getUserById(int userId) {
// Data access logic to retrieve a user from the database
// ...
}
}
The Service Activator Pattern is used to invoke a service asynchronously. An example of this pattern is a JMS (Java Message Service) listener that waits for a messaging request and delegates it to an appropriate service. Here's a high-level example:
public class ServiceActivator {
public void activateService(ServiceRequest request) {
// Asynchronously invoke the service based on the request
// ...
}
}
In conclusion, design patterns are invaluable tools for designing and architecting software systems. They provide tested and proven solutions to recurring design problems. By applying these design patterns in your Java applications, you can enhance code reusability, maintainability, and scalability, ultimately leading to more robust and efficient software.
Sometimes it is useful to get the output of a command and paste it to a text editor. For this we can use piping and the clip (i.e. sends the output to Windows clipboard) command.
Example:
If we go to any directory and run the tree command but it returns a very long output that exceeds the screen. We can redirect the output to Windows clipboard temporarily then paste it to a text editor.
%USERPROFILE%>tree
Where %USERPROFILE% is normally resolves to our local home directory.
The output might not fit to command terminal screen.
%USERPROFILE%>tree | clip
You will see no output because it is directed to a Windows clipboard.
Check if you can confirm the last entries from step 2 exists to our pasted output.
Binding coordinates state transfer between the component's class and its template. The following table shows the different types of Angular data bindings.
Type | Description | Direction | Example |
---|---|---|---|
Interpolation | Evaluates the expression between the double curly braces. | One-way (Component→Template) | <h1>{{header}}</h1> |
Property Binding | Updates the property if there's a change from the bound component state. This is typically denoted by the square bracket surrounding the target property. | One-way (Component→Template) | <img [src]='imageURL'/> |
Event Binding | Updates the bound component state if an event's was fired. This is typically denoted by the parenthesis surrounding the event property. | One-way (Component←Template) | <button (click)='onSave'>Save</button> |
Two-Way Binding | Normally use with the form elements. This is typically denoted by the combined square and parenthesis surrounding the ngModel property. | Two-way (Component↔Template) | <input type='text' [(ngModel)]='name'/> |
The JavaScript's facility to provide inheritance is via prototype property of the constructor function (i.e. accessible via __proto__ in the instance context). Thus, we normally use the prototype to make properties and functions possible to be inherited. See the following code to do the inheritance properly.
"use strict"; function Person(firstName, lastName) { this.firstName = firstName; this.lastName = lastName; } Person.prototype.middleName = ""; Object.defineProperty(Person.prototype, 'fullName', { get: function() { var name = (this.firstName||""); name += (name.length>0 ? " " : "") + (this.middleName||""); name += (name.length>0 ? " " : "") + (this.lastName||""); return name; }, set: function(name) { var DELIM = " "; var names = (name||"").split(DELIM); this.firstName = names[0]; this.lastName = names[1]; } }); function Employee(firstName, lastName, position) { Person.call(this, firstName, lastName); this.position = position||""; } Employee.prototype = Object.create(Person.prototype); Employee.prototype.constructor = Employee; var person = new Person(); person.fullName = "Ron Webb"; console.log(person.fullName); var employee = new Employee("Ofelia", "Webb", "Manager"); console.log(employee.fullName); console.log(employee.position);
Based on preceding code, the Employee is inheriting the Person via the following snippet:
Employee.prototype = Object.create(Person.prototype);
But, we should not stop there. We need to also specify the constructor to use the create the instance of Employee like the following snippet:
Employee.prototype.constructor = Employee;
Lastly, in the constructor implementation of the Employee try to also call the constructor of the Person like the following snippet:
function Employee(firstName, lastName, position) { Person.call(this, firstName, lastName); this.position = position||""; }
With ES6, this was greatly simplified because we don't need to deal with the prototype property of the constructor function like the following code:
"use strict"; class Person { constructor(firstName, lastName) { this.firstName = firstName; this.lastName = lastName; this.middleName = ""; } get fullName() { var name = (this.firstName||""); name += (name.length>0 ? " " : "") + (this.middleName||""); name += (name.length>0 ? " " : "") + (this.lastName||""); return name; } set fullName(name) { const DELIM = " "; var names = (name||"").split(DELIM); this.firstName = names[0]; this.lastName = names[1]; } } class Employee extends Person { constructor(firstName, lastName, position) { super(firstName, lastName); this.position = position||""; } } var person = new Person(); person.fullName = "Ron Webb"; console.log(person.fullName); var employee = new Employee("Ofelia", "Webb", "Manager"); console.log(employee.fullName); console.log(employee.position);
In ES6, we can now use the class keyword to define a class and a constructor method for its initialization. Regarding the constructor, we can now use the super method to call the parent constructor.
Moreover, implementing getter (i.e. using the get keyword before the function name) and setter (i.e. using the set keyword before the function name) are now very simple. Also the const keyword is now available to define immutable identifier just like what we can see on the fullName setter as we can see in the following snippet:
set fullName(name) { const DELIM = " "; var names = (name||"").split(DELIM); this.firstName = names[0]; this.lastName = names[1]; }
All these enhancements in ES6 related to inheritance, in the background it still using the prototypical way. Remember these are just syntactic sugar.
React renders component based on any changes on its state (i.e. data).
In React, a form input component controlled by it is known as controlled component. These components maintains their own state and update itself based on user input as depicted by the following code:
const MessageView = (props) => { return( <h1>{props.message}</h1> ); } class App extends React.Component { state = { message : "" }; handleMsgChange = (event) => { this.setState({ message: event.target.value }); } render() { return( <div> <input type="text" placeholder="Type Something" value={this.state.message} onChange={this.handleMsgChange}/> <MessageView message={this.state.message}/> </div> ); } } ReactDOM.render(<App />, mountNode);
The App component above has a message attribute in state as seen in the following snippet:
state = { message : "" };
We can bound the message attribute to the text input via the value attribute and listen to the changes on itself using the onChange attribute which in turn updates the state of the message like the following snippet:
<input type="text" placeholder="Type Something" value={this.state.message} onChange={this.handleMsgChange}/>
The handleMsgChange that is bound to text input onChange attribute must update the message state of the React App component and could have the following implementation. This makes the React state as the single source of truth.
handleMsgChange = (event) => { this.setState({ message: event.target.value }); }
This particular implementation will also trigger the re-render of the MessageView component since it is also dependent to the state of the message as we can see in the following snippet:
<MessageView message={this.state.message}/>
React might batch multiple setState function calls into a single update for performance. Thus the correct way to change the React state is by using the setState function that accepts a function instead of object like the following snippet:
this.setState((prevState, props) => { //Do the state update here. })
Let us try to create a reusable ButtonClear component that will clear value of the message attribute with the following snippet.
const ButtonClear = (props) => { if (props.visible) { return( <button onClick={props.handleClear}>Clear</button> ); } return(null); //Returns nothing }
Based on the preceding snippet the ButtonClean component will only display the clear button if we tell it to make it visible via its visible attribute. Moreover, it is also expecting to have a handleClear implementation that will be bound to button's onClick attribute.
The handleClear implementation will be provided by the App component like the following snippet with the recommended usage of the setState() function:
handleClear = () => { this.setState((prevState, props) => { return {message: ""}; //Clears the message }); }
Thus we can use the ButtonClear component in the App component like the following snippet:
<ButtonClear handleClear={this.handleClear} visible={this.state.message!=""}/>
We also instructed it to make the clear button visible only if the message is not empty.
The updated complete code with ButtonClear component can be seen as follows:
const MessageView = (props) => { return( <h1>{props.message}</h1> ); } const ButtonClear = (props) => { if (props.visible) { return( <button onClick={props.handleClear}>Clear</button> ); } return(null); } class App extends React.Component { state = { message : "" }; handleMsgChange = (event) => { this.setState({ message: event.target.value }); } handleClear = () => { this.setState((prevState, props) => { return {message: ""}; //Clears the message. }); } render() { return( <div> <input type="text" placeholder="Type Something" value={this.state.message} onChange={this.handleMsgChange}/> <ButtonClear handleClear={this.handleClear} visible={this.state.message!=""}/> <MessageView message={this.state.message}/> </div> ); } } ReactDOM.render(<App />, mountNode);
Note: We can run both Code 1 and Code 2 using jsComplete Playground
Functional interface is an interface with a single abstract method (SAM).
Interface Name | Arguments | Returns |
---|---|---|
BiConsumer<T,U> | (T, U) | void |
BiFunction<T, U, R> | (T, U) | R |
BinaryOperator<T> | (T, T) | T |
BiPredicate<T,U> | (T, U) | boolean |
Consumer<T> | T | void |
Function<T, R> | T | R |
Predicate<T> | T | boolean |
Supplier<T> | T | |
UnaryOperator<T> | T | T |
Implementing hot observable can be achieved with RxJava's PublishSubject. Moreover, we will try to publish data to the subject concurrently safely (i.e. using the synchronized keyword). Thus the complete code at the bottom uses several threads for publishing data and several threads for subscription.
A simple way to create an instance of the PublishSubject instance is by invoking the static method create like the following snippet (see the complete code at the bottom).
PublishSubject subject = PublishSubject.create();
Sending data to a PublishSubject instance can be done by calling its onNext method. Place the actual call in a synchronized block if we are sending data concurrently like the following snippet (see the complete code at the bottom):
synchronized (subject) { subject.onNext(String.valueOf(strItem)); }
To listen to any of the data sent to a PublishSubject instance we can use one of the subscribe method. In addition, we can also opt to use the computation Scheduler (i.e. normally the Scheduler is the one responsible to managing threads in a multi-threaded environment.) via the observeOn method (i.e. for some reason the subscribeOn method is not working with PublishSubject instance.) like the following snippet (see the complete code at the bottom):
subject.observeOn(Schedulers.computation()) .subscribe(___item -> { System.out.println(_name + " ThreadID:" + Thread.currentThread().getId() + ": " + ___item); });
package xyz.ronella.reactive; import rx.schedulers.Schedulers; import rx.subjects.PublishSubject; import java.util.ArrayList; import java.util.List; import java.util.concurrent.*; import java.util.stream.IntStream; public class PublishedObservable { public static void main(String ... args) { final PublishSubject subject = PublishSubject.create(); List publishers = new ArrayList<>(); List subscribers = new ArrayList<>(); int defaultThreadCount = 3; ExecutorService executorPublisher = Executors.newFixedThreadPool(defaultThreadCount); ExecutorService executorSubscriber = Executors.newFixedThreadPool(defaultThreadCount); class LocalPublisher implements Runnable { private long _item; private String _name; private PublishSubject _subject; public LocalPublisher(String name, long itemStart, PublishSubject subject) { this._name = name; this._item = itemStart; this._subject = subject; } @Override public void run() { try { while(true) { Thread.sleep(1000); String strItem = String.valueOf(++_item); System.out.println("\n" + _name + " ThreadID:" + Thread.currentThread().getId() + ": " + strItem); synchronized (_subject) { _subject.onNext(String.valueOf(strItem)); } } } catch (InterruptedException e) { System.out.println(_name + " interrupted."); } } } class LocalSubscriber implements Runnable { private String _name; private PublishSubject _subject; public LocalSubscriber(String name, PublishSubject subject) { this._name = name; this._subject = subject; } @Override public void run() { _subject.observeOn(Schedulers.computation()) .subscribe(___item -> { System.out.println(_name + " ThreadID:" + Thread.currentThread().getId() + ": " + ___item); }); } } IntStream.rangeClosed(1, 3).forEach(___idx -> subscribers.add(executorSubscriber.submit(new LocalSubscriber("Subscriber " + ___idx, subject)))); IntStream.rangeClosed(1, 6).forEach(___idx -> publishers.add(executorPublisher.submit(new LocalPublisher("Publisher " + ___idx,___idx * 100, subject)))); subject.subscribe( ___item -> System.out.println("Main - ThreadID:" + Thread.currentThread().getId() + " " + ___item)); try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } executorPublisher.shutdownNow(); executorSubscriber.shutdown(); } }
© 2024 Ron and Ella Wiki Page
Theme by Anders Noren — Up ↑
Recent Comments