Shweta Patil

Hello. My name is Shanta. I currently work as an application developer in EBD at Sintech. My responsibilities include developing API and Spring-based applications. I have around 7 years of experience. During these 7 years, I've worked across different domains, including banking and ecommerce. Currently, I'm working in logistics and transport domains. I have experience with technologies like JSP, Spring Boot, Hibernate, and Spring Batch. Apart from that, I have experience with relational databases such as MySQL and Oracle. I don't have much exposure to microservices, but I do work on premise systems and have a solid understanding of the fundamentals. I know how to utilize these concepts in software development. That's all about me.

How would you implement the robot strategy of having a transaction in a distributor's payment application? Okay, so in a distributor's payment application, we can use a programmatic and distributed transaction management. So, in my project, we have to use annotation-based transaction management where we can annotate a method with the accurate transactional annotation. And there, we can set the propagation level and the rollback. In rollback, we can mention the class name or give them a new customer exception, which should be triggered on that particular transaction. And we can set the isolation levels and the timeout as well. So, using a transaction annotation, we can implement a robust pass strategy for full transaction and distributed Spring Boot application.

I would do well in Hibernate session factory settings and have a current Java application. So, the session factory is, it provides an application level of the session. So, it sets the session type fields in creating the session object. And for highly confident applications, we can create a session type of object which will ensure the session object is properly set up. And I think by using that way, we can ensure the Hibernate session is properly set up during the end of this application.

In the distributed transaction, as I mentioned earlier, we can use a transactional annotation where we can save the solution level transaction level as a transaction or the new transaction is safe. We can set it like that. The rule back functionality we can set and the time out we can set using that way. We can ensure the asset property that is our domestic consistency, isolation, and with our BP, we can make sure those asset properties are being followed in another string of the application by using the transactional annotation in either the service layer or the data access layer.

So we have a low latency high throughput application. In that case, we can go for the big plan where they can make a concurrent call that is a non-blocking call. We can make our application asynchronous using enable asynchronous and asynchronous annotation on the method, so that multiple threads can move concurrently. And using that, we can design a low latency and high throughput job application.

Implementing the optimistic, looking in this scenario. I think we can you know, all the entities which are, getting access by multiple threads on that, we can save the log annotation by using Hibernate to achieve the optimistic lock feature.

Yeah. So there's an issue when it comes to the multithreading environment because the single thread design pattern is implemented using the lazy initialization technique. So, here, we need to handle the synchronized translation by using a synchronized method or a synchronized block. The most preferable day is using the synchronized block because it locks the minimum amount of code and it doesn't increase the waiting period of the other threads. So we can use a synchronized lock inside this instance-sequestered transformers. And it will create an instance when the instance is in demand.

I don't see any principal is getting audited. It's all of the inheritance. Method overriding. The only thing I could see is using set width. We are setting the width as well as the height and using set height. We are setting the width as well as the height. So using the width, we can set just the width. And using the height, we can just set the height. So I think that is, I mean, the important principle will be, you know, I think the single responsibility principle that is, or one class should have one responsibility that is not being followed. So I think that is the one we should.

What technique would you try to streamline crystal or classic? Okay. So, in my project, I have to use the screen batch, which is processing a massive data using the screen batch where we have to use a job. Then the job can have multiple steps and each step consists of an item reader, item processor, and item writer. And, it's processing the data in chunks. Like, instead of reading one data and then writing and processing that, it is reading a cross-section of the data, processing that, and writing that. So, you know, so we can use Spring Batch technique to streamline the processing of massive datasets. This is a bigger hybrid. I think it doesn't need auto language here.

Test coverage for standard application, how would you go about how to do this with this for physical ideas? So I don't have any experience with testing. So I will have some time for this question. So

So for enhancing the security of a JavaScript application, eliminating external APIs, we can implement spam and security using by extending a bit of security from your adapter and enabling bit security on that class. We can override the configure method, which can be customized to security rules, such as URL path and the rules, like admin or user. We can also override the configure method to provide an authentication provider, such as in-memory authentication. In my project, I have used in-memory authentication. Apart from that, we can go for JWT or Okta implementation for integrating security. Also, if we have resources on different origins, we can handle cross-origin in our Spring Boot application by using the @CrossOrigin annotation and providing the path. So, I think by using these strategies, we can make the application more secure.