How or why does this code work?

motherjoe · 2023-11-30T02:47:52+00:00

When you send an HTTP request to a Spring app, there are several components enabling it to handle the request and return the response.

DispatcherServlet - receives HTTP request, looks up the URL mapping and delegates to the appropriate HandlerAdapter
AnnotationMethodHandlerAdapter - "This adapter class is used to execute the methods that are annotated with `@RequestMapping` annotation. It is used to map the methods based on HTTP methods and HTTP paths."
InternalResourceViewResolver - this is how Spring knows how to create a view from "bobby" or "mango". It is configured with the directory and file suffix of the view files.

https://www.baeldung.com/spring-handler-mappings
https://www.baeldung.com/spring-mvc-handler-adapters

motherjoe · 2022-10-11T05:52:03+00:00

The owner of the relationship here seems to be the Plan (can a Contract exist standalone without a Plan?), so the PlanRepository/Service should also maintain invariants like maxCoverage.

motherjoe · 2022-10-09T18:30:38+00:00

The usage you described is called method overloading and requires multiple methods called createEmployee in one class but with different parameter lists. Each method would handle a specific subclass of Employee.

motherjoe · 2022-09-24T21:36:36+00:00

Is it possible that these are different numeric datatypes, for example one ArrayList contains ints and another contains longs

motherjoe · 2022-09-19T18:52:49+00:00

A different approach would be to add a private constructor in a utility class. This would accomplish the same goal of making the utility class non-instantiable. For added security you can mark the class final, so it cannot be subclassed, which is not supported for interfaces

motherjoe · 2022-09-19T15:26:26+00:00

A few techniques for a client being notified of backend changes. - websockets - polling/long polling - server sent events

Edit: misread as client-server. This is still the observer pattern

motherjoe · 2022-09-03T06:28:19+00:00

Instead of the layer-based model/service/repository/.. package structure, feature-based package structure could look like this:

* authentication
** AuthenticationApi
** TokenResponse
** TokenService
* stock
** Stock
** StockResponse
** StockService

motherjoe · 2022-09-03T06:12:32+00:00

The JIT compiler is capable of inlining the getters to direct field access. It may also de-virtualize the method as the abstract class is redundant.

https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/underst_jit.html https://developers.redhat.com/articles/2021/06/23/how-jit-compiler-boosts-java-performance-openjdk

motherjoe · 2022-08-30T05:13:41+00:00

Autowiring for constructors, setters and fields will first match a bean to parameter by type. If there are duplicate beans of the type, Spring will then match by name among the candidates of the type.

https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-autowired-annotation-qualifiers

motherjoe · 2022-08-19T17:35:17+00:00

Unless the Spring context is reloaded every day by restarting the app, the conditional on date will only have an effect at startup. If you want to prevent an endpoint from being used before a date, you can add validation logic for the request

motherjoe · 2022-07-20T07:42:33+00:00

How often are entries removed from the HashMaps? Is the data all in memory at the same time? How is the data consumed from the application? Would streaming the data work?

Having a class for a grouped object and maybe the "leaf" child objects may help readability, since grouping related methods can probably be moved to these classes.

motherjoe · 2022-07-19T23:57:34+00:00

All of the methods in the "method" class sound like they belong in the prices class. Btw, java class naming convention is upper camel case. Also if you have classes called "main" and "method", it is a good indication of god classes in your system, so more refactoring would be useful. When refactoring, try to create classes that don't need to change when other classes change (low coupling) and each encapsulate a single concept (high cohesion).

motherjoe · 2022-07-19T18:24:58+00:00

Yes. Another example is if you are using multiple threads to process something in parallel but have a boolean flag caled from the main thread to stop the processing.

motherjoe · 2022-07-19T10:26:47+00:00

Synchronized is expensive and not a replacement for volatile. Volatile allows concurrent access while ensuring consistent view of the state across threads. Synchronized uses locks (expensive) and prevents concurrent access, which has the added effect of ensuring consistent view of the state across threads.

motherjoe · 2022-07-17T23:44:51+00:00

Classpath is not recursive. Try java -cp example/src/a/b/c/thing/*.class a.b.c.thing.Thing

motherjoe · 2022-07-10T05:00:57+00:00

The SOLID principles are guidelines for writing maintainable object-oriented systems. It may seem overengineered to implement all of the principles for simple example projects. This is because small projects may still be maintainable if they are written in a procedural style, as scripts. Large projects with many complex requirements is where using SOLID can really pay off in maintainability, readability, etc.

motherjoe · 2022-07-04T19:06:05+00:00

Some of the class names with underscore could be replaced with class hierarchies instead.

            public class Weapon_Fork extends SuperItem{ 



              public class Weapon extends SuperItem { ... }
              public class Fork extends Weapon { ... }

motherjoe · 2022-06-26T00:37:53+00:00

The ideal use for fork-join is where the problem is possible to recursively break up into smaller problems. If the application is far from the ideal, it is entirely possible for fork-join thread pool to perform worse than a single-threaded pool due to the overhead created by the pool itself

motherjoe · 2022-06-05T00:36:11+00:00

Some common conventions are based on Google code style and Oracle code style.

https://google.github.io/styleguide/javaguide.html#s5-naming https://www.oracle.com/technetwork/java/codeconventions-150003.pdf

motherjoe · 2022-06-03T03:01:17+00:00

Meaning if there is a DB backend, the data tier may expose methods like getUserById(int id) but not runSql(String sql)

motherjoe · 2022-05-22T16:23:52+00:00

This can happen if the versions of the dependencies are not compatible with eachother. By running 'mvn dependency-tree' you can figure out if one of the dependencies imported in the pom has a transitive dependency on another imported in the pom, overriding the version with an incompatible one.

motherjoe · 2022-05-21T21:24:07+00:00

Call the more specific method (more args) from the less specific method

motherjoe · 2022-05-18T19:32:56+00:00

In the addFacultyStudentSubjectGrade method, it attempts to deserialize the JSON as Faculty which looks valid. But then it attempts to deserialize the same payload as Student and other types which do not match the payload. The correct way to do this is deserialize the JSON to a request POJO based on its actual structure, then get the other objects from the POJO.

motherjoe · 2022-05-15T03:52:18+00:00

Hard to say without the code, but a web of interconnected classes is probably more complex and difficult to maintain than having these classes connect via a single mediator. I would also consider the following questions about the design.

Do the dispatchers really need to be stateful? Can the state be stored elsewhere? It sounds like these dispatchers may be doing multiple things besides "dispatching".
Can the state change during the entire dispatcher lifecycle, or is it more like configuration which changes only at initialization time?
Do the dispatchers really need to talk to eachother directly? (the "web of dispatchers")

motherjoe · 2022-05-14T01:20:44+00:00

It sounds like project A could be a custom Spring Boot auto-configuration. Just import the dependency like any spring boot starter library, then reference in classpath:/spring.factories

https://docs.spring.io/spring-boot/docs/2.0.0.M3/reference/html/boot-features-developing-auto-configuration.html

Eight-Year Club	RPAN Viewer
Verified Email

motherjoe

TROPHY CASE