modern-web-app | Modern Web Application Architecture in Java | Object-Relational Mapping library

The Baeldung article Spring Security Authentication Provider has an example that I think suits your needs.

Simply create your own authentication provider that authenticates as you see fit, and then register it in your security configuration.

You use interfaces to be able to change implementations without modifiying your code.

If in a future you use another "way" of sending mails, you just need to change the IMailSender implementation and that's all. Otherwise you would need to refactor all your code depending on your MailSender implementation.

Normally you would use your IMailSender interface also in your validation project. So yes, this intertface should reside in a common library, which will be referenced by both libraries.

Then you will inject (normally via IoC) the implementation in your services, which depend on IMailSender

Usually your Infrastructure library will have have the implementations of your interfaces (some of them may be declared in your "core" library and others...) which will be injected in the classes using it.

So the "infrastructure library" is a way to abstract you implementations, so your code soes not rely on specific classes but on interfaces, being way easier to refactor/change in a future.

There are some other points (it also depends if you are using DDD etc..here every Domain has its own infrastructure) but for me this is the main "reason" of an infrastructure layer.

In this case I would not duplicate the interface, as long as you need the same functionality in both libraries. If not the case, then create two interfaces, each serving the specific needs.

First problem is that Stock was defining two ids (id form AbstractEntity and Ticker) and is not implementing Serializable.

For the second issue...just add this.stockService = stockService in MainView constructor

Solved by adding the following dependency

I don't think that this diagram belongs to any UML type, isn't it?

That does not follow UML notation, for instance as I know the only cases of a rectangle with dotted border are regions(interruptible, expansion) in an activity and your diagram is not at all for an activity.

Does this diagram follow any kind of standard notation?

The more important is not to know if the notation looks like something from UML but to know what is represented.

As the title indicate that diagram shows the architecture, but with mixed types of elements, the closer possible in UML seems to be a deployment diagram, a little bit more far component diagram.

The reason it violates the persistence ignorance principle is very simple: you have to make the properties virtual to make EF happy, so you changed the business code duo to a persistence concern. And besides directly violating the principle, using features of EF that override members of your class change the type of the class, so, for example, in your Equals implementation, you cannot use GetType() anymore to compare the two instances, as the actual type of the object is generated by EF at runtime, so again, you start to change your domain logic according to persistence concerns. On a side note, I would also advise against using EF's lazy loading in most cases, because it only works synchronously, blocking the current thread.

Turns out not running the uglify() task will make it work. Removing that line and rerunning the gulp task, I can debug the original code in the browser and see the variable values.

It seems if you run javascript minification with gulp-uglify or gulp-terser you won't be able to view the variables in the debugger. This is the the same problem in chrome Debugging variables not working with gulp sourcemaps + uglify

As far I understand, the actual path of the process is layer based and precisely equivalent to n-tier version (only differing in how it's drawn, which should be irrelevant).

Yes, that's right.

Is the main difference between those two architecture types simply how we're using them or is there an actual difference code-wise or in the project structure (except for the naming, of course)?

The difference is which code knows about, has references to, depends on other code.

In N-Tier, the business logic needs to know the API of the infrastructure layer. All of the dependencies point down.

In clean architecture/onion architecture, etc, the infrastructure layer knows about the API of the domain layer. All of the dependencies point inward.

Clean architecture puts the business logic and application model at the center of the application. Instead of having business logic depend on data access or other infrastructure concerns, this dependency is inverted: infrastructure and implementation details depend on the Application Core.

This style is often accompanied by the use of a Composition Root, which is responsible for wiring together the components that will eventually do the work.

Are you saying that there's no business logic layer in onion version? I.e. that it's baked in into the application core?

Typically, business logic is understood to be in the middle of the onion. For instance, Robert Martin offers

You may find that you need more than just these four. There’s no rule that says you must always have just these four. However, The Dependency Rule always applies. Source code dependencies always point inwards.

if I understand you correctly, you want to put all pipeline related operations, sdev scripts related to the solution level.

in the picture above, they are not focusing on that, it is focused on the code itself.

so I suggest having this structure instead